@nx/devkit 17.2.0-beta.2 → 17.2.0-beta.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nx/devkit",
-  "version": "17.2.0-beta.2",
+  "version": "17.2.0-beta.4",
   "private": false,
   "description": "The Nx Devkit is used to customize Nx for different technologies and use cases. It contains many utility functions for reading and writing files, updating configuration, working with Abstract Syntax Trees(ASTs), and more. Learn more about [extending Nx by leveraging the Nx Devkit](https://nx.dev/extending-nx/intro/getting-started) on our docs.",
   "repository": {
@@ -34,7 +34,7 @@
     "tmp": "~0.2.1",
     "tslib": "^2.3.0",
     "semver": "7.5.3",
-    "@nrwl/devkit": "17.2.0-beta.2"
+    "@nrwl/devkit": "17.2.0-beta.4"
   },
   "peerDependencies": {
     "nx": ">= 16 <= 18"

package/src/generators/project-name-and-root-utils.js

@@ -6,15 +6,18 @@ const path_1 = require("path");
 const nx_1 = require("../../nx");
 const get_workspace_layout_1 = require("../utils/get-workspace-layout");
 const names_1 = require("../utils/names");
-const { joinPathFragments, normalizePath, logger, readJson, stripIndents, workspaceRoot, } = (0, nx_1.requireNx)();
-const deprecationWarning = stripIndents `
-    In Nx 18, generating projects will no longer derive the name and root.
-    Please provide the exact project name and root in the future.`;
+const { joinPathFragments, logger, normalizePath, output, readJson, stripIndents, workspaceRoot, } = (0, nx_1.requireNx)();
 async function determineProjectNameAndRootOptions(tree, options) {
+    if (!options.projectNameAndRootFormat &&
+        (process.env.NX_INTERACTIVE !== 'true' || !isTTY())) {
+        options.projectNameAndRootFormat = 'derived';
+    }
     validateName(options.name, options.projectNameAndRootFormat);
     const formats = getProjectNameAndRootFormats(tree, options);
-    const format = options.projectNameAndRootFormat ??
-        (await determineFormat(tree, formats, options.callingGenerator));
+    const format = options.projectNameAndRootFormat ?? (await determineFormat(formats));
+    if (format === 'derived' && options.callingGenerator) {
+        logDeprecationMessage(options.callingGenerator, formats);
+    }
     return {
         ...formats[format],
         projectNameAndRootFormat: format,
@@ -41,16 +44,17 @@ function validateName(name, projectNameAndRootFormat) {
         throw new Error(`The project name should match the pattern "${pattern}". The provided value "${name}" does not match.`);
     }
 }
-function getExample(callingGenerator, formats) {
-    return `Example: nx g ${callingGenerator} ${formats['derived'].projectName} --directory ${formats['derived'].projectRoot}`;
+function logDeprecationMessage(callingGenerator, formats) {
+    logger.warn(stripIndents `
+    In Nx 18, generating projects will no longer derive the name and root.
+    Please provide the exact project name and root in the future.
+    Example: nx g ${callingGenerator} ${formats['derived'].projectName} --directory ${formats['derived'].projectRoot}
+  `);
 }
-async function determineFormat(tree, formats, callingGenerator) {
+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'].projectName}
     Root: ${formats['as-provided'].projectRoot}`;
@@ -78,113 +82,154 @@ async function determineFormat(tree, formats, callingGenerator) {
         ],
         initial: 'as-provided',
     }).then(({ format }) => format === asProvidedSelectedValue ? 'as-provided' : 'derived');
-    if (result === 'derived' && callingGenerator) {
-        const example = getExample(callingGenerator, formats);
-        logger.warn(deprecationWarning + '\n' + example);
-    }
     return result;
 }
 function getProjectNameAndRootFormats(tree, options) {
     const directory = options.directory
         ? normalizePath(options.directory.replace(/^\.?\//, ''))
         : undefined;
-    const asProvidedProjectName = options.name;
-    let asProvidedProjectDirectory;
-    const relativeCwd = normalizePath((0, path_1.relative)(workspaceRoot, getCwd())).replace(/\/$/, '');
-    if (directory) {
+    const { name: asProvidedParsedName, directory: asProvidedParsedDirectory } = parseNameForAsProvided(options.name);
+    if (asProvidedParsedDirectory && directory) {
+        throw new Error(`You can't specify both a directory (${options.directory}) and a name with a directory path (${options.name}). ` +
+            `Please specify either a directory or a name with a directory path.`);
+    }
+    const asProvidedOptions = getAsProvidedOptions(tree, {
+        ...options,
+        directory: directory ?? asProvidedParsedDirectory,
+        name: asProvidedParsedName,
+    });
+    if (options.projectNameAndRootFormat === 'as-provided') {
+        return {
+            'as-provided': asProvidedOptions,
+            derived: undefined,
+        };
+    }
+    if (asProvidedOptions.projectName.startsWith('@')) {
+        if (!options.projectNameAndRootFormat) {
+            output.warn({
+                title: `The provided name "${options.name}" contains a scoped project name and this is not supported by the "${options.callingGenerator}" when using the "derived" format.`,
+                bodyLines: [
+                    `The generator will try to generate the project "${asProvidedOptions.projectName}" using the "as-provided" format at "${asProvidedOptions.projectRoot}".`,
+                ],
+            });
+            return {
+                'as-provided': asProvidedOptions,
+                derived: undefined,
+            };
+        }
+        throw new Error(`The provided name "${options.name}" contains a scoped project name and this is not supported by the "${options.callingGenerator}" when using the "derived" format. ` +
+            `Please provide a name without "@" or use the "as-provided" format.`);
+    }
+    const { name: derivedParsedName, directory: derivedParsedDirectory } = parseNameForDerived(options.name);
+    const derivedOptions = getDerivedOptions(tree, {
+        ...options,
+        directory: directory ?? derivedParsedDirectory,
+        name: derivedParsedName,
+    });
+    return {
+        'as-provided': asProvidedOptions,
+        derived: derivedOptions,
+    };
+}
+function getAsProvidedOptions(tree, options) {
+    let projectSimpleName;
+    let projectFileName;
+    if (options.name.startsWith('@')) {
+        const [_scope, ...rest] = options.name.split('/');
+        projectFileName = rest.join('-');
+        projectSimpleName = rest.pop();
+    }
+    else {
+        projectSimpleName = options.name;
+        projectFileName = options.name;
+    }
+    let projectRoot;
+    const relativeCwd = getRelativeCwd();
+    if (options.directory) {
         // append the directory to the current working directory if it doesn't start with it
-        if (directory === relativeCwd || directory.startsWith(`${relativeCwd}/`)) {
-            asProvidedProjectDirectory = directory;
+        if (options.directory === relativeCwd ||
+            options.directory.startsWith(`${relativeCwd}/`)) {
+            projectRoot = options.directory;
         }
         else {
-            asProvidedProjectDirectory = joinPathFragments(relativeCwd, directory);
+            projectRoot = joinPathFragments(relativeCwd, options.directory);
         }
     }
     else if (options.rootProject) {
-        asProvidedProjectDirectory = '.';
+        projectRoot = '.';
     }
     else {
-        asProvidedProjectDirectory = relativeCwd;
+        projectRoot = relativeCwd;
         // append the project name to the current working directory if it doesn't end with it
-        if (!relativeCwd.endsWith(asProvidedProjectName) &&
-            !relativeCwd.endsWith(options.name)) {
-            asProvidedProjectDirectory = joinPathFragments(relativeCwd, asProvidedProjectName);
+        if (!relativeCwd.endsWith(options.name)) {
+            projectRoot = joinPathFragments(relativeCwd, options.name);
         }
     }
-    if (asProvidedProjectName.startsWith('@')) {
-        const nameWithoutScope = asProvidedProjectName.split('/')[1];
-        return {
-            'as-provided': {
-                projectName: asProvidedProjectName,
-                names: {
-                    projectSimpleName: nameWithoutScope,
-                    projectFileName: nameWithoutScope,
-                },
-                importPath: options.importPath ?? asProvidedProjectName,
-                projectRoot: asProvidedProjectDirectory,
-            },
-        };
-    }
-    let asProvidedImportPath;
-    let npmScope;
+    let importPath = undefined;
     if (options.projectType === 'library') {
-        asProvidedImportPath = options.importPath;
-        if (!asProvidedImportPath) {
-            npmScope = getNpmScope(tree);
-            asProvidedImportPath =
-                asProvidedProjectDirectory === '.'
-                    ? readJson(tree, 'package.json').name ??
-                        getImportPath(npmScope, asProvidedProjectName)
-                    : getImportPath(npmScope, asProvidedProjectName);
+        importPath = options.importPath;
+        if (!importPath) {
+            if (options.name.startsWith('@')) {
+                importPath = options.name;
+            }
+            else {
+                const npmScope = getNpmScope(tree);
+                importPath =
+                    projectRoot === '.'
+                        ? readJson(tree, 'package.json').name ??
+                            getImportPath(npmScope, options.name)
+                        : getImportPath(npmScope, options.name);
+            }
         }
     }
+    return {
+        projectName: options.name,
+        names: {
+            projectSimpleName,
+            projectFileName,
+        },
+        importPath,
+        projectRoot,
+    };
+}
+function getDerivedOptions(tree, options) {
     const name = (0, names_1.names)(options.name).fileName;
-    let { projectDirectory, layoutDirectory } = getDirectories(tree, directory, options.projectType);
-    const derivedProjectDirectoryWithoutLayout = projectDirectory
+    let { projectDirectory, layoutDirectory } = getDirectories(tree, options.directory, options.projectType);
+    const projectDirectoryWithoutLayout = projectDirectory
         ? `${(0, names_1.names)(projectDirectory).fileName}/${name}`
         : options.rootProject
             ? '.'
             : name;
     // the project name uses the directory without the layout directory
-    const derivedProjectName = derivedProjectDirectoryWithoutLayout === '.'
+    const projectName = projectDirectoryWithoutLayout === '.'
         ? name
-        : derivedProjectDirectoryWithoutLayout.replace(/\//g, '-');
-    const derivedSimpleProjectName = name;
-    let derivedProjectDirectory = derivedProjectDirectoryWithoutLayout;
-    if (derivedProjectDirectoryWithoutLayout !== '.') {
+        : projectDirectoryWithoutLayout.replace(/\//g, '-');
+    const projectSimpleName = name;
+    let projectRoot = projectDirectoryWithoutLayout;
+    if (projectDirectoryWithoutLayout !== '.') {
         // prepend the layout directory
-        derivedProjectDirectory = joinPathFragments(layoutDirectory, derivedProjectDirectory);
+        projectRoot = joinPathFragments(layoutDirectory, projectRoot);
     }
-    let derivedImportPath;
+    let importPath;
     if (options.projectType === 'library') {
-        derivedImportPath = options.importPath;
-        if (!derivedImportPath) {
-            derivedImportPath =
-                derivedProjectDirectory === '.'
+        importPath = options.importPath;
+        if (!importPath) {
+            const npmScope = getNpmScope(tree);
+            importPath =
+                projectRoot === '.'
                     ? readJson(tree, 'package.json').name ??
-                        getImportPath(npmScope, derivedProjectName)
-                    : getImportPath(npmScope, derivedProjectDirectoryWithoutLayout);
+                        getImportPath(npmScope, projectName)
+                    : getImportPath(npmScope, projectDirectoryWithoutLayout);
         }
     }
     return {
-        'as-provided': {
-            projectName: asProvidedProjectName,
-            names: {
-                projectSimpleName: asProvidedProjectName,
-                projectFileName: asProvidedProjectName,
-            },
-            importPath: asProvidedImportPath,
-            projectRoot: asProvidedProjectDirectory,
-        },
-        derived: {
-            projectName: derivedProjectName,
-            names: {
-                projectSimpleName: derivedSimpleProjectName,
-                projectFileName: derivedProjectName,
-            },
-            importPath: derivedImportPath,
-            projectRoot: derivedProjectDirectory,
+        projectName,
+        names: {
+            projectSimpleName,
+            projectFileName: projectName,
         },
+        importPath,
+        projectRoot,
     };
 }
 function getDirectories(tree, directory, projectType) {
@@ -218,6 +263,9 @@ function getCwd() {
         ? process.env.INIT_CWD
         : process.cwd();
 }
+function getRelativeCwd() {
+    return normalizePath((0, path_1.relative)(workspaceRoot, getCwd())).replace(/\/$/, '');
+}
 /**
  * Function for setting cwd during testing
  */
@@ -225,3 +273,26 @@ function setCwd(path) {
     process.env.INIT_CWD = (0, path_1.join)(workspaceRoot, path);
 }
 exports.setCwd = setCwd;
+function parseNameForAsProvided(rawName) {
+    const directory = normalizePath(rawName);
+    if (rawName.includes('@')) {
+        const index = directory.lastIndexOf('@');
+        if (index === 0) {
+            return { name: rawName, directory: undefined };
+        }
+        const name = directory.substring(index);
+        return { name, directory };
+    }
+    if (rawName.includes('/')) {
+        const index = directory.lastIndexOf('/');
+        const name = directory.substring(index + 1);
+        return { name, directory };
+    }
+    return { name: rawName, directory: undefined };
+}
+function parseNameForDerived(rawName) {
+    const parsedName = normalizePath(rawName).split('/');
+    const name = parsedName.pop();
+    const directory = parsedName.length ? parsedName.join('/') : undefined;
+    return { name, directory };
+}