@nx/workspace 17.3.0-canary.20231213-3655269 → 17.3.0-canary.20231215-ca32d14

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nx/workspace",
-  "version": "17.3.0-canary.20231213-3655269",
+  "version": "17.3.0-canary.20231215-ca32d14",
   "private": false,
   "description": "The Workspace plugin contains executors and generators that are useful for any Nx workspace. It should be present in every Nx workspace and other plugins build on it.",
   "repository": {
@@ -61,13 +61,13 @@
     }
   },
   "dependencies": {
-    "@nx/devkit": "17.3.0-canary.20231213-3655269",
+    "@nx/devkit": "17.3.0-canary.20231215-ca32d14",
     "chalk": "^4.1.0",
     "enquirer": "~2.3.6",
     "tslib": "^2.3.0",
     "yargs-parser": "21.1.1",
-    "nx": "17.3.0-canary.20231213-3655269",
-    "@nrwl/workspace": "17.3.0-canary.20231213-3655269"
+    "nx": "17.3.0-canary.20231215-ca32d14",
+    "@nrwl/workspace": "17.3.0-canary.20231215-ca32d14"
   },
   "publishConfig": {
     "access": "public"

package/src/generators/convert-to-monorepo/convert-to-monorepo.js

@@ -11,10 +11,14 @@ async function monorepoGenerator(tree, options) {
     const projectsToMove = [];
     // Need to determine libs vs packages directory base on the type of root project.
     for (const [, project] of projects) {
-        if (project.root === '.')
+        if (project.root === '.') {
             rootProject = project;
-        projectsToMove.unshift(project); // move the root project 1st
+        }
+        else {
+            projectsToMove.push(project);
+        }
     }
+    projectsToMove.unshift(rootProject); // move the root project 1st
     // Currently, Nx only handles apps+libs or packages. You cannot mix and match them.
     // If the standalone project is an app (React, Angular, etc), then use apps+libs.
     // Otherwise, for TS standalone (lib), use packages.

package/src/generators/move/lib/create-project-configuration-in-new-destination.js

@@ -5,7 +5,7 @@ const devkit_1 = require("@nx/devkit");
 function createProjectConfigurationInNewDestination(tree, schema, projectConfig) {
     projectConfig.name = schema.newProjectName;
     const isRootProject = projectConfig.root === '.';
-    // Subtle bug if project name === path, where the updated name was being overrideen.
+    // Subtle bug if project name === path, where the updated name was being overridden.
     const { name, ...rest } = projectConfig;
     // replace old root path with new one
     let newProjectString = JSON.stringify(rest);
@@ -17,7 +17,12 @@ function createProjectConfigurationInNewDestination(tree, schema, projectConfig)
         newProjectString = newProjectString.replace(/"(\.\/)?src\/(.*?)"/g, `"${schema.relativeToRootDestination}/src/$2"`);
     }
     else {
-        newProjectString = newProjectString.replace(new RegExp(projectConfig.root, 'g'), schema.relativeToRootDestination);
+        // There's another issue if project name === path, where the target
+        // string (my-app:build:production) was being replaced
+        // and resulting in my-destination/my-new-name:build:production
+        // Change anything but target strings (my-app:build:production).
+        // Target string are going to be updated in the updateBuildTargets function
+        newProjectString = newProjectString.replace(new RegExp(projectConfig.root + '(?!:)', 'g'), schema.relativeToRootDestination);
     }
     const newProject = {
         name,

package/src/generators/move/lib/extract-base-configs.d.ts

@@ -1,4 +1,4 @@
 import { ProjectConfiguration, Tree } from '@nx/devkit';
 export declare function maybeExtractTsConfigBase(tree: Tree): void;
 export declare function maybeExtractJestConfigBase(tree: Tree): Promise<void>;
-export declare function maybeExtractEslintConfigIfRootProject(tree: Tree, rootProject: ProjectConfiguration): void;
+export declare function maybeMigrateEslintConfigIfRootProject(tree: Tree, rootProject: ProjectConfiguration): void;

package/src/generators/move/lib/extract-base-configs.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.maybeExtractEslintConfigIfRootProject = exports.maybeExtractJestConfigBase = exports.maybeExtractTsConfigBase = void 0;
+exports.maybeMigrateEslintConfigIfRootProject = exports.maybeExtractJestConfigBase = exports.maybeExtractTsConfigBase = void 0;
 const devkit_1 = require("@nx/devkit");
 function maybeExtractTsConfigBase(tree) {
     let extractTsConfigBase;
@@ -26,11 +26,7 @@ async function maybeExtractJestConfigBase(tree) {
     await jestInitGenerator(tree, {});
 }
 exports.maybeExtractJestConfigBase = maybeExtractJestConfigBase;
-function maybeExtractEslintConfigIfRootProject(tree, rootProject) {
-    if (rootProject.root !== '.')
-        return;
-    if (tree.exists('.eslintrc.base.json'))
-        return;
+function maybeMigrateEslintConfigIfRootProject(tree, rootProject) {
     let migrateConfigToMonorepoStyle;
     try {
         migrateConfigToMonorepoStyle = require('@nx/' +
@@ -39,11 +35,9 @@ function maybeExtractEslintConfigIfRootProject(tree, rootProject) {
     catch {
         // eslint not installed
     }
-    // Only need to handle migrating the root rootProject.
-    // If other libs/apps exist, then this migration is already done by `@nx/eslint:lint-rootProject` generator.
-    migrateConfigToMonorepoStyle?.([rootProject], tree, tree.exists((0, devkit_1.joinPathFragments)(rootProject.root, 'jest.config.ts')) ||
+    migrateConfigToMonorepoStyle?.(Array.from((0, devkit_1.getProjects)(tree).values()), tree, tree.exists((0, devkit_1.joinPathFragments)(rootProject.root, 'jest.config.ts')) ||
         tree.exists((0, devkit_1.joinPathFragments)(rootProject.root, 'jest.config.js'))
         ? 'jest'
         : 'none');
 }
-exports.maybeExtractEslintConfigIfRootProject = maybeExtractEslintConfigIfRootProject;
+exports.maybeMigrateEslintConfigIfRootProject = maybeMigrateEslintConfigIfRootProject;

package/src/generators/move/lib/normalize-schema.d.ts

@@ -1,3 +1,3 @@
-import { ProjectConfiguration, Tree } from '@nx/devkit';
+import { type ProjectConfiguration, type Tree } from '@nx/devkit';
 import type { NormalizedSchema, Schema } from '../schema';
 export declare function normalizeSchema(tree: Tree, schema: Schema, projectConfiguration: ProjectConfiguration): Promise<NormalizedSchema>;

package/src/generators/move/lib/normalize-schema.js

@@ -17,10 +17,16 @@ async function normalizeSchema(tree, schema, projectConfiguration) {
 }
 exports.normalizeSchema = normalizeSchema;
 async function determineProjectNameAndRootOptions(tree, options, projectConfiguration) {
+    if (!options.projectNameAndRootFormat &&
+        (process.env.NX_INTERACTIVE !== 'true' || !isTTY())) {
+        options.projectNameAndRootFormat = 'derived';
+    }
     validateName(options.newProjectName, options.projectNameAndRootFormat, projectConfiguration);
     const formats = getProjectNameAndRootFormats(tree, options, projectConfiguration);
-    const format = options.projectNameAndRootFormat ??
-        (await determineFormat(tree, formats, options));
+    const format = options.projectNameAndRootFormat ?? (await determineFormat(formats));
+    if (format === 'derived') {
+        logDeprecationMessage(formats, options);
+    }
     return formats[format];
 }
 function validateName(name, projectNameAndRootFormat, projectConfiguration) {
@@ -55,65 +61,47 @@ function validateName(name, projectNameAndRootFormat, projectConfiguration) {
         }
     }
 }
-function getProjectNameAndRootFormats(tree, schema, projectConfiguration) {
-    let destination = (0, utils_1.normalizePathSlashes)(schema.destination);
-    const normalizedNewProjectName = schema.newProjectName
-        ? (0, devkit_1.names)(schema.newProjectName).fileName
-        : undefined;
-    const asProvidedProjectName = normalizedNewProjectName ?? schema.projectName;
-    const asProvidedDestination = destination;
-    if (normalizedNewProjectName?.startsWith('@')) {
+function getProjectNameAndRootFormats(tree, options, projectConfiguration) {
+    let destination = (0, utils_1.normalizePathSlashes)(options.destination);
+    if (options.newProjectName &&
+        options.newProjectName.includes('/') &&
+        !options.newProjectName.startsWith('@')) {
+        throw new Error(`You can't specify a new project name with a directory path (${options.newProjectName}). ` +
+            `Please provide a valid name without path segments and the full destination with the "--destination" option.`);
+    }
+    const asProvidedOptions = getAsProvidedOptions(tree, { ...options, destination }, projectConfiguration);
+    if (options.projectNameAndRootFormat === 'as-provided') {
         return {
-            'as-provided': {
-                destination: asProvidedDestination,
-                importPath: schema.importPath ??
-                    // keep the existing import path if the name didn't change
-                    (normalizedNewProjectName &&
-                        schema.projectName !== normalizedNewProjectName
-                        ? asProvidedProjectName
-                        : undefined),
-                newProjectName: asProvidedProjectName,
-            },
+            'as-provided': asProvidedOptions,
+            derived: undefined,
         };
     }
-    let npmScope;
-    let asProvidedImportPath = schema.importPath;
-    if (!asProvidedImportPath &&
-        schema.newProjectName &&
-        projectConfiguration.projectType === 'library') {
-        npmScope = (0, get_import_path_1.getNpmScope)(tree);
-        asProvidedImportPath = npmScope
-            ? `${npmScope === '@' ? '' : '@'}${npmScope}/${asProvidedProjectName}`
-            : asProvidedProjectName;
-    }
-    const derivedProjectName = schema.newProjectName ?? (0, utils_1.getNewProjectName)(destination);
-    const derivedDestination = (0, utils_1.getDestination)(tree, schema, projectConfiguration);
-    let derivedImportPath;
-    if (projectConfiguration.projectType === 'library') {
-        derivedImportPath =
-            schema.importPath ??
-                (0, utils_1.normalizePathSlashes)((0, get_import_path_1.getImportPath)(tree, destination));
+    if (asProvidedOptions.newProjectName.startsWith('@')) {
+        if (!options.projectNameAndRootFormat) {
+            devkit_1.output.warn({
+                title: `The provided new project name "${asProvidedOptions.newProjectName}" is a scoped project name and this is not supported by the move generator when using the "derived" format.`,
+                bodyLines: [
+                    `The generator will try to move the project using the "as-provided" format with the new name "${asProvidedOptions.newProjectName}" located at "${asProvidedOptions.destination}".`,
+                ],
+            });
+            return {
+                'as-provided': asProvidedOptions,
+                derived: undefined,
+            };
+        }
+        throw new Error(`The provided new project name "${options.newProjectName}" is a scoped project name and this is not supported by the move generator when using the "derived" format. ` +
+            `Please provide a name without "@" or use the "as-provided" format.`);
     }
+    const derivedOptions = getDerivedOptions(tree, { ...options, destination }, projectConfiguration);
     return {
-        'as-provided': {
-            destination: asProvidedDestination,
-            newProjectName: asProvidedProjectName,
-            importPath: asProvidedImportPath,
-        },
-        derived: {
-            destination: derivedDestination,
-            newProjectName: derivedProjectName,
-            importPath: derivedImportPath,
-        },
+        'as-provided': asProvidedOptions,
+        derived: derivedOptions,
     };
 }
-async function determineFormat(tree, formats, schema) {
+async function determineFormat(formats) {
     if (!formats.derived) {
         return 'as-provided';
     }
-    if (process.env.NX_INTERACTIVE !== 'true' || !isTTY()) {
-        return 'derived';
-    }
     const asProvidedDescription = `As provided:
     Name: ${formats['as-provided'].newProjectName}
     Destination: ${formats['as-provided'].destination}`;
@@ -138,38 +126,57 @@ async function determineFormat(tree, formats, schema) {
         ],
         initial: 'as-provided',
     }).then(({ format }) => format === asProvidedSelectedValue ? 'as-provided' : 'derived');
+    return result;
+}
+function logDeprecationMessage(formats, options) {
     const callingGenerator = process.env.NX_ANGULAR_MOVE_INVOKED === 'true'
         ? '@nx/angular:move'
         : '@nx/workspace:move';
-    const deprecationWarning = (0, devkit_1.stripIndents) `
+    devkit_1.logger.warn((0, devkit_1.stripIndents) `
     In Nx 18, the project name and destination will no longer be derived.
-    Please provide the exact new project name and destination in the future.`;
-    if (result === 'as-provided') {
-        const { saveDefault } = await (0, enquirer_1.prompt)({
-            type: 'confirm',
-            message: `Would you like to configure Nx to always take the project name and destination as provided for ${callingGenerator}?`,
-            name: 'saveDefault',
-            initial: true,
-        });
-        if (saveDefault) {
-            const nxJson = (0, devkit_1.readNxJson)(tree);
-            nxJson.generators ??= {};
-            nxJson.generators[callingGenerator] ??= {};
-            nxJson.generators[callingGenerator].projectNameAndRootFormat = result;
-            (0, devkit_1.updateNxJson)(tree, nxJson);
-        }
-        else {
-            devkit_1.logger.warn(deprecationWarning);
-        }
+    Please provide the exact new project name and destination in the future.
+    Example: nx g ${callingGenerator} --projectName ${options.projectName} --destination ${formats['derived'].destination}` +
+        (options.projectName !== formats['derived'].newProjectName
+            ? ` --newProjectName ${formats['derived'].newProjectName}`
+            : ''));
+}
+function getAsProvidedOptions(tree, options, projectConfiguration) {
+    const newProjectName = options.newProjectName ?? options.projectName;
+    const destination = options.destination;
+    if (projectConfiguration.projectType !== 'library') {
+        return { destination, newProjectName };
     }
-    else {
-        const example = `Example: nx g ${callingGenerator} --projectName ${schema.projectName} --destination ${formats[result].destination}` +
-            (schema.projectName !== formats[result].newProjectName
-                ? ` --newProjectName ${formats[result].newProjectName}`
-                : '');
-        devkit_1.logger.warn(deprecationWarning + '\n' + example);
+    let importPath = options.importPath;
+    if (importPath) {
+        return { destination, newProjectName, importPath };
     }
-    return result;
+    if (options.newProjectName?.startsWith('@')) {
+        // keep the existing import path if the name didn't change
+        importPath =
+            options.newProjectName && options.projectName !== options.newProjectName
+                ? newProjectName
+                : undefined;
+    }
+    else if (options.newProjectName) {
+        const npmScope = (0, get_import_path_1.getNpmScope)(tree);
+        importPath = npmScope
+            ? `${npmScope === '@' ? '' : '@'}${npmScope}/${newProjectName}`
+            : newProjectName;
+    }
+    return { destination, newProjectName, importPath };
+}
+function getDerivedOptions(tree, options, projectConfiguration) {
+    const newProjectName = options.newProjectName
+        ? (0, devkit_1.names)(options.newProjectName).fileName
+        : (0, utils_1.getNewProjectName)(options.destination);
+    const destination = (0, utils_1.getDestination)(tree, options, projectConfiguration);
+    let importPath;
+    if (projectConfiguration.projectType === 'library') {
+        importPath =
+            options.importPath ??
+                (0, utils_1.normalizePathSlashes)((0, get_import_path_1.getImportPath)(tree, options.destination));
+    }
+    return { destination, newProjectName, importPath };
 }
 function isTTY() {
     return !!process.stdout.isTTY && process.env['CI'] !== 'true';

package/src/generators/move/move.js

@@ -33,7 +33,6 @@ async function moveGeneratorInternal(tree, rawSchema) {
     if (projectConfig.root === '.') {
         (0, extract_base_configs_1.maybeExtractTsConfigBase)(tree);
         await (0, extract_base_configs_1.maybeExtractJestConfigBase)(tree);
-        (0, extract_base_configs_1.maybeExtractEslintConfigIfRootProject)(tree, projectConfig);
         // Reload config since it has been updated after extracting base configs
         projectConfig = (0, devkit_1.readProjectConfiguration)(tree, rawSchema.projectName);
     }
@@ -51,6 +50,10 @@ async function moveGeneratorInternal(tree, rawSchema) {
     (0, update_build_targets_1.updateBuildTargets)(tree, schema);
     (0, update_default_project_1.updateDefaultProject)(tree, schema);
     (0, update_implicit_dependencies_1.updateImplicitDependencies)(tree, schema);
+    if (projectConfig.root === '.') {
+        // we want to migrate eslint config once the root project files are moved
+        (0, extract_base_configs_1.maybeMigrateEslintConfigIfRootProject)(tree, projectConfig);
+    }
     await (0, run_angular_plugin_1.runAngularPlugin)(tree, schema);
     if (!schema.skipFormat) {
         await (0, devkit_1.formatFiles)(tree);