@nx/devkit 0.0.0-pr-22179-271588f

package/src/generators/artifact-name-and-directory-utils.js

@@ -0,0 +1,239 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setCwd = exports.getRelativeCwd = exports.determineArtifactNameAndDirectoryOptions = void 0;
+const enquirer_1 = require("enquirer");
+const path_1 = require("path");
+const nx_1 = require("../../nx");
+const names_1 = require("../utils/names");
+const { createProjectRootMappingsFromProjectConfigurations, findProjectForPath, getProjects, joinPathFragments, logger, normalizePath, output, workspaceRoot, } = (0, nx_1.requireNx)();
+async function determineArtifactNameAndDirectoryOptions(tree, options) {
+    if (!options.nameAndDirectoryFormat &&
+        (process.env.NX_INTERACTIVE !== 'true' || !isTTY())) {
+        options.nameAndDirectoryFormat = 'derived';
+    }
+    const formats = getNameAndDirectoryOptionFormats(tree, options);
+    const format = options.nameAndDirectoryFormat ?? (await determineFormat(formats, options));
+    validateResolvedProject(tree, formats[format]?.project, options, formats[format]?.directory);
+    if (format === 'derived' && options.callingGenerator) {
+        logDeprecationMessage(options, formats);
+    }
+    return {
+        ...formats[format],
+        nameAndDirectoryFormat: format,
+    };
+}
+exports.determineArtifactNameAndDirectoryOptions = determineArtifactNameAndDirectoryOptions;
+async function determineFormat(formats, options) {
+    if (!formats.derived) {
+        return 'as-provided';
+    }
+    const asProvidedDescription = `As provided: ${formats['as-provided'].filePath}`;
+    const asProvidedSelectedValue = formats['as-provided'].filePath;
+    const derivedDescription = `Derived:     ${formats['derived'].filePath}`;
+    const derivedSelectedValue = formats['derived'].filePath;
+    if (asProvidedSelectedValue === derivedSelectedValue) {
+        return 'as-provided';
+    }
+    const result = await (0, enquirer_1.prompt)({
+        type: 'select',
+        name: 'format',
+        message: `Where should the ${options.artifactType} be generated?`,
+        choices: [
+            {
+                message: asProvidedDescription,
+                name: asProvidedSelectedValue,
+            },
+            {
+                message: derivedDescription,
+                name: derivedSelectedValue,
+            },
+        ],
+        initial: 0,
+    }).then(({ format }) => format === asProvidedSelectedValue ? 'as-provided' : 'derived');
+    return result;
+}
+function logDeprecationMessage(options, formats) {
+    logger.warn(`
+In Nx 19, generating a ${options.artifactType} will no longer support providing a project and deriving the directory.
+Please provide the exact directory in the future.
+Example: nx g ${options.callingGenerator} ${formats['derived'].artifactName} --directory ${formats['derived'].directory}
+NOTE: The example above assumes the command is being run from the workspace root. If the command is being run from a subdirectory, the directory option should be adjusted accordingly.
+`);
+}
+function getNameAndDirectoryOptionFormats(tree, options) {
+    const directory = options.directory
+        ? normalizePath(options.directory.replace(/^\.?\//, ''))
+        : undefined;
+    const fileExtension = options.fileExtension ?? 'ts';
+    const { name: extractedName, directory: extractedDirectory } = extractNameAndDirectoryFromName(options.name);
+    if (extractedDirectory && 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 ?? extractedDirectory,
+        fileExtension,
+        name: extractedName,
+    });
+    if (!options.project) {
+        validateResolvedProject(tree, asProvidedOptions.project, options, asProvidedOptions.directory);
+    }
+    if (options.nameAndDirectoryFormat === 'as-provided') {
+        return {
+            'as-provided': asProvidedOptions,
+            derived: undefined,
+        };
+    }
+    if (options.disallowPathInNameForDerived && options.name.includes('/')) {
+        if (!options.nameAndDirectoryFormat) {
+            output.warn({
+                title: `The provided name "${options.name}" contains a path and this is not supported by the "${options.callingGenerator}" when using the "derived" format.`,
+                bodyLines: [
+                    `The generator will try to generate the ${options.artifactType} using the "as-provided" format at "${asProvidedOptions.filePath}".`,
+                ],
+            });
+            return {
+                'as-provided': asProvidedOptions,
+                derived: undefined,
+            };
+        }
+        throw new Error(`The provided name "${options.name}" contains a path and this is not supported by the "${options.callingGenerator}" when using the "derived" format. ` +
+            `Please provide a name without a path or use the "as-provided" format.`);
+    }
+    const derivedOptions = getDerivedOptions(tree, {
+        ...options,
+        directory,
+        fileExtension,
+        name: extractedName,
+    }, asProvidedOptions, !options.disallowPathInNameForDerived && extractedDirectory
+        ? extractedDirectory
+        : undefined);
+    return {
+        'as-provided': asProvidedOptions,
+        derived: derivedOptions,
+    };
+}
+function getAsProvidedOptions(tree, options) {
+    const relativeCwd = getRelativeCwd();
+    const asProvidedDirectory = options.directory
+        ? joinPathFragments(relativeCwd, options.directory)
+        : relativeCwd;
+    const asProvidedProject = findProjectFromPath(tree, asProvidedDirectory);
+    const asProvidedFileName = options.fileName ??
+        (options.suffix ? `${options.name}.${options.suffix}` : options.name);
+    const asProvidedFilePath = joinPathFragments(asProvidedDirectory, `${asProvidedFileName}.${options.fileExtension}`);
+    return {
+        artifactName: options.name,
+        directory: asProvidedDirectory,
+        fileName: asProvidedFileName,
+        filePath: asProvidedFilePath,
+        project: asProvidedProject,
+    };
+}
+function getDerivedOptions(tree, options, asProvidedOptions, extractedDirectory) {
+    const projects = getProjects(tree);
+    if (options.project && !projects.has(options.project)) {
+        throw new Error(`The provided project "${options.project}" does not exist! Please provide an existing project name.`);
+    }
+    const projectName = options.project ?? asProvidedOptions.project;
+    const project = projects.get(projectName);
+    const derivedName = options.name;
+    const baseDirectory = options.directory
+        ? (0, names_1.names)(options.directory).fileName
+        : joinPathFragments(project.sourceRoot ?? joinPathFragments(project.root, 'src'), project.projectType === 'application' ? 'app' : 'lib', extractedDirectory ?? '');
+    const derivedDirectory = typeof options.derivedDirectory === 'string'
+        ? joinPathFragments(project.sourceRoot ?? project.root, options.derivedDirectory, options.flat
+            ? ''
+            : options.pascalCaseDirectory
+                ? (0, names_1.names)(derivedName).className
+                : (0, names_1.names)(derivedName).fileName)
+        : options.flat
+            ? normalizePath(baseDirectory)
+            : joinPathFragments(baseDirectory, options.pascalCaseDirectory
+                ? (0, names_1.names)(derivedName).className
+                : (0, names_1.names)(derivedName).fileName);
+    if (options.directory &&
+        !isDirectoryUnderProjectRoot(derivedDirectory, project.root)) {
+        if (!options.nameAndDirectoryFormat) {
+            output.warn({
+                title: `The provided directory "${options.directory}" is not under the provided project root "${project.root}".`,
+                bodyLines: [
+                    `The generator will try to generate the ${options.artifactType} using the "as-provided" format.`,
+                    `With the "as-provided" format, the "project" option is ignored and the ${options.artifactType} will be generated at "${asProvidedOptions.filePath}" (<cwd>/<provided directory>).`,
+                ],
+            });
+            return undefined;
+        }
+        throw new Error(`The provided directory "${options.directory}" is not under the provided project root "${project.root}". ` +
+            `Please provide a directory that is under the provided project root or use the "as-provided" format and only provide the directory.`);
+    }
+    let derivedFileName = options.fileName;
+    if (!derivedFileName) {
+        derivedFileName = options.suffix
+            ? `${derivedName}.${options.suffix}`
+            : derivedName;
+        derivedFileName = options.pascalCaseFile
+            ? (0, names_1.names)(derivedFileName).className
+            : (0, names_1.names)(derivedFileName).fileName;
+    }
+    const derivedFilePath = joinPathFragments(derivedDirectory, `${derivedFileName}.${options.fileExtension}`);
+    return {
+        artifactName: derivedName,
+        directory: derivedDirectory,
+        fileName: derivedFileName,
+        filePath: derivedFilePath,
+        project: projectName,
+    };
+}
+function validateResolvedProject(tree, project, options, normalizedDirectory) {
+    if (project) {
+        return;
+    }
+    if (options.directory) {
+        throw new Error(`The provided directory resolved relative to the current working directory "${normalizedDirectory}" does not exist under any project root. ` +
+            `Please make sure to navigate to a location or provide a directory that exists under a project root.`);
+    }
+    throw new Error(`The current working directory "${getRelativeCwd() || '.'}" does not exist under any project root. ` +
+        `Please make sure to navigate to a location or provide a directory that exists under a project root.`);
+}
+function findProjectFromPath(tree, path) {
+    const projectConfigurations = {};
+    const projects = getProjects(tree);
+    for (const [projectName, project] of projects) {
+        projectConfigurations[projectName] = project;
+    }
+    const projectRootMappings = createProjectRootMappingsFromProjectConfigurations(projectConfigurations);
+    return findProjectForPath(path, projectRootMappings);
+}
+function isDirectoryUnderProjectRoot(directory, projectRoot) {
+    const normalizedDirectory = joinPathFragments(workspaceRoot, directory);
+    const normalizedProjectRoot = joinPathFragments(workspaceRoot, projectRoot).replace(/\/$/, '');
+    return (normalizedDirectory === normalizedProjectRoot ||
+        normalizedDirectory.startsWith(`${normalizedProjectRoot}/`));
+}
+function isTTY() {
+    return !!process.stdout.isTTY && process.env['CI'] !== 'true';
+}
+function getRelativeCwd() {
+    return normalizePath((0, path_1.relative)(workspaceRoot, getCwd()));
+}
+exports.getRelativeCwd = getRelativeCwd;
+/**
+ * Function for setting cwd during testing
+ */
+function setCwd(path) {
+    process.env.INIT_CWD = (0, path_1.join)(workspaceRoot, path);
+}
+exports.setCwd = setCwd;
+function getCwd() {
+    return process.env.INIT_CWD?.startsWith(workspaceRoot)
+        ? process.env.INIT_CWD
+        : process.cwd();
+}
+function extractNameAndDirectoryFromName(rawName) {
+    const parsedName = normalizePath(rawName).split('/');
+    const name = parsedName.pop();
+    const directory = parsedName.length ? parsedName.join('/') : undefined;
+    return { name, directory };
+}

package/src/generators/executor-options-utils.d.ts

@@ -0,0 +1,21 @@
+import type { Tree } from 'nx/src/generators/tree';
+import type { ProjectGraph } from 'nx/src/config/project-graph';
+type CallBack<T> = (currentValue: T, project: string, target: string, configuration?: string) => void;
+/**
+ * Calls a function for each different options that an executor is configured with
+ */
+export declare function forEachExecutorOptions<Options>(tree: Tree, 
+/**
+ * Name of the executor to update options for
+ */
+executorName: string, 
+/**
+ * Callback that is called for each options configured for a builder
+ */
+callback: CallBack<Options>): void;
+/**
+ * Calls a function for each different options that an executor is configured with via the project graph
+ * this is helpful when you need to get the expaned configuration options from the nx.json
+ **/
+export declare function forEachExecutorOptionsInGraph<Options>(graph: ProjectGraph, executorName: string, callback: CallBack<Options>): void;
+export {};

package/src/generators/executor-options-utils.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.forEachExecutorOptionsInGraph = exports.forEachExecutorOptions = void 0;
+const nx_1 = require("../../nx");
+const { getProjects } = (0, nx_1.requireNx)();
+/**
+ * Calls a function for each different options that an executor is configured with
+ */
+function forEachExecutorOptions(tree, 
+/**
+ * Name of the executor to update options for
+ */
+executorName, 
+/**
+ * Callback that is called for each options configured for a builder
+ */
+callback) {
+    forEachProjectConfig(getProjects(tree), executorName, callback);
+}
+exports.forEachExecutorOptions = forEachExecutorOptions;
+/**
+ * Calls a function for each different options that an executor is configured with via the project graph
+ * this is helpful when you need to get the expaned configuration options from the nx.json
+ **/
+function forEachExecutorOptionsInGraph(graph, executorName, callback) {
+    const projects = new Map();
+    Object.values(graph.nodes).forEach((p) => projects.set(p.name, p.data));
+    forEachProjectConfig(projects, executorName, callback);
+}
+exports.forEachExecutorOptionsInGraph = forEachExecutorOptionsInGraph;
+function forEachProjectConfig(projects, executorName, callback) {
+    for (const [projectName, project] of projects) {
+        for (const [targetName, target] of Object.entries(project.targets || {})) {
+            if (executorName !== target.executor) {
+                continue;
+            }
+            if (target.options) {
+                callback(target.options, projectName, targetName);
+            }
+            if (!target.configurations) {
+                continue;
+            }
+            Object.entries(target.configurations).forEach(([configName, options]) => {
+                callback(options, projectName, targetName, configName);
+            });
+        }
+    }
+}
+// TODO: add a method for updating options

package/src/generators/format-files.d.ts

@@ -0,0 +1,6 @@
+import type { Tree } from 'nx/src/generators/tree';
+/**
+ * Formats all the created or updated files using Prettier
+ * @param tree - the file system tree
+ */
+export declare function formatFiles(tree: Tree): Promise<void>;

package/src/generators/format-files.js

@@ -0,0 +1,91 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.formatFiles = void 0;
+const path = require("path");
+const nx_1 = require("../../nx");
+let { updateJson, readJson, sortObjectByKeys } = (0, nx_1.requireNx)();
+// TODO: Remove this in Nx 19 when Nx 16.7.0 is no longer supported
+sortObjectByKeys =
+    sortObjectByKeys ?? require('nx/src/utils/object-sort').sortObjectByKeys;
+/**
+ * Formats all the created or updated files using Prettier
+ * @param tree - the file system tree
+ */
+async function formatFiles(tree) {
+    let prettier;
+    try {
+        prettier = await Promise.resolve().then(() => require('prettier'));
+    }
+    catch { }
+    sortTsConfig(tree);
+    if (!prettier)
+        return;
+    const files = new Set(tree.listChanges().filter((file) => file.type !== 'DELETE'));
+    const changedPrettierInTree = getChangedPrettierConfigInTree(tree);
+    await Promise.all(Array.from(files).map(async (file) => {
+        try {
+            const systemPath = path.join(tree.root, file.path);
+            const resolvedOptions = await prettier.resolveConfig(systemPath, {
+                editorconfig: true,
+            });
+            const options = {
+                ...resolvedOptions,
+                ...changedPrettierInTree,
+                filepath: systemPath,
+            };
+            if (file.path.endsWith('.swcrc')) {
+                options.parser = 'json';
+            }
+            const support = await prettier.getFileInfo(systemPath, options);
+            if (support.ignored || !support.inferredParser) {
+                return;
+            }
+            tree.write(file.path, 
+            // In prettier v3 the format result is a promise
+            await prettier.format(file.content.toString('utf-8'), options));
+        }
+        catch (e) {
+            console.warn(`Could not format ${file.path}. Error: "${e.message}"`);
+        }
+    }));
+}
+exports.formatFiles = formatFiles;
+function sortTsConfig(tree) {
+    try {
+        const tsConfigPath = getRootTsConfigPath(tree);
+        if (!tsConfigPath) {
+            return;
+        }
+        updateJson(tree, tsConfigPath, (tsconfig) => ({
+            ...tsconfig,
+            compilerOptions: {
+                ...tsconfig.compilerOptions,
+                paths: sortObjectByKeys(tsconfig.compilerOptions.paths),
+            },
+        }));
+    }
+    catch (e) {
+        // catch noop
+    }
+}
+function getRootTsConfigPath(tree) {
+    for (const path of ['tsconfig.base.json', 'tsconfig.json']) {
+        if (tree.exists(path)) {
+            return path;
+        }
+    }
+    return null;
+}
+function getChangedPrettierConfigInTree(tree) {
+    if (tree.listChanges().find((file) => file.path === '.prettierrc')) {
+        try {
+            return readJson(tree, '.prettierrc');
+        }
+        catch {
+            return null;
+        }
+    }
+    else {
+        return null;
+    }
+}

package/src/generators/generate-files.d.ts

@@ -0,0 +1,26 @@
+import type { Tree } from 'nx/src/generators/tree';
+/**
+ * Generates a folder of files based on provided templates.
+ *
+ * While doing so it performs two substitutions:
+ * - Substitutes segments of file names surrounded by __
+ * - Uses ejs to substitute values in templates
+ *
+ * Examples:
+ * ```typescript
+ * generateFiles(tree, path.join(__dirname , 'files'), './tools/scripts', {tmpl: '', name: 'myscript'})
+ * ```
+ * This command will take all the files from the `files` directory next to the place where the command is invoked from.
+ * It will replace all `__tmpl__` with '' and all `__name__` with 'myscript' in the file names, and will replace all
+ * `<%= name %>` with `myscript` in the files themselves.
+ * `tmpl: ''` is a common pattern. With it you can name files like this: `index.ts__tmpl__`, so your editor
+ * doesn't get confused about incorrect TypeScript files.
+ *
+ * @param tree - the file system tree
+ * @param srcFolder - the source folder of files (absolute path)
+ * @param target - the target folder (relative to the tree root)
+ * @param substitutions - an object of key-value pairs
+ */
+export declare function generateFiles(tree: Tree, srcFolder: string, target: string, substitutions: {
+    [k: string]: any;
+}): void;

package/src/generators/generate-files.js

@@ -0,0 +1,91 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateFiles = void 0;
+const fs_1 = require("fs");
+const path = require("path");
+const nx_1 = require("../../nx");
+const binary_extensions_1 = require("../utils/binary-extensions");
+const { logger } = (0, nx_1.requireNx)();
+/**
+ * Generates a folder of files based on provided templates.
+ *
+ * While doing so it performs two substitutions:
+ * - Substitutes segments of file names surrounded by __
+ * - Uses ejs to substitute values in templates
+ *
+ * Examples:
+ * ```typescript
+ * generateFiles(tree, path.join(__dirname , 'files'), './tools/scripts', {tmpl: '', name: 'myscript'})
+ * ```
+ * This command will take all the files from the `files` directory next to the place where the command is invoked from.
+ * It will replace all `__tmpl__` with '' and all `__name__` with 'myscript' in the file names, and will replace all
+ * `<%= name %>` with `myscript` in the files themselves.
+ * `tmpl: ''` is a common pattern. With it you can name files like this: `index.ts__tmpl__`, so your editor
+ * doesn't get confused about incorrect TypeScript files.
+ *
+ * @param tree - the file system tree
+ * @param srcFolder - the source folder of files (absolute path)
+ * @param target - the target folder (relative to the tree root)
+ * @param substitutions - an object of key-value pairs
+ */
+function generateFiles(tree, srcFolder, target, substitutions) {
+    const ejs = require('ejs');
+    const files = allFilesInDir(srcFolder);
+    if (files.length === 0) {
+        throw new Error(`generateFiles: No files found in "${srcFolder}". Are you sure you specified the correct path?`);
+    }
+    else {
+        files.forEach((filePath) => {
+            let newContent;
+            const computedPath = computePath(srcFolder, target, filePath, substitutions);
+            if ((0, binary_extensions_1.isBinaryPath)(filePath)) {
+                newContent = (0, fs_1.readFileSync)(filePath);
+            }
+            else {
+                const template = (0, fs_1.readFileSync)(filePath, 'utf-8');
+                try {
+                    newContent = ejs.render(template, substitutions, {
+                        filename: filePath,
+                    });
+                }
+                catch (e) {
+                    logger.error(`Error in ${filePath.replace(`${tree.root}/`, '')}:`);
+                    throw e;
+                }
+            }
+            tree.write(computedPath, newContent);
+        });
+    }
+}
+exports.generateFiles = generateFiles;
+function computePath(srcFolder, target, filePath, substitutions) {
+    const relativeFromSrcFolder = path.relative(srcFolder, filePath);
+    let computedPath = path.join(target, relativeFromSrcFolder);
+    if (computedPath.endsWith('.template')) {
+        computedPath = computedPath.substring(0, computedPath.length - 9);
+    }
+    Object.entries(substitutions).forEach(([propertyName, value]) => {
+        computedPath = computedPath.split(`__${propertyName}__`).join(value);
+    });
+    return computedPath;
+}
+function allFilesInDir(parent) {
+    let res = [];
+    try {
+        (0, fs_1.readdirSync)(parent).forEach((c) => {
+            const child = path.join(parent, c);
+            try {
+                const s = (0, fs_1.statSync)(child);
+                if (!s.isDirectory()) {
+                    res.push(child);
+                }
+                else if (s.isDirectory()) {
+                    res = [...res, ...allFilesInDir(child)];
+                }
+            }
+            catch { }
+        });
+    }
+    catch { }
+    return res;
+}

package/src/generators/project-name-and-root-utils.d.ts

@@ -0,0 +1,47 @@
+import type { ProjectType } from 'nx/src/config/workspace-json-project-json';
+import type { Tree } from 'nx/src/generators/tree';
+export type ProjectNameAndRootFormat = 'as-provided' | 'derived';
+export type ProjectGenerationOptions = {
+    name: string;
+    projectType: ProjectType;
+    callingGenerator: string | null;
+    directory?: string;
+    importPath?: string;
+    projectNameAndRootFormat?: ProjectNameAndRootFormat;
+    rootProject?: boolean;
+};
+export type ProjectNameAndRootOptions = {
+    /**
+     * Normalized full project name, including scope if name was provided with
+     * scope (e.g., `@scope/name`, only available when `projectNameAndRootFormat`
+     * is `as-provided`).
+     */
+    projectName: string;
+    /**
+     * Normalized project root, including the layout directory if configured.
+     */
+    projectRoot: string;
+    names: {
+        /**
+         * Normalized project name without scope. It's meant to be used when
+         * generating file names that contain the project name.
+         */
+        projectFileName: string;
+        /**
+         * Normalized project name without scope or directory. It's meant to be used
+         * when generating shorter file names that contain the project name.
+         */
+        projectSimpleName: string;
+    };
+    /**
+     * Normalized import path for the project.
+     */
+    importPath?: string;
+};
+export declare function determineProjectNameAndRootOptions(tree: Tree, options: ProjectGenerationOptions): Promise<ProjectNameAndRootOptions & {
+    projectNameAndRootFormat: ProjectNameAndRootFormat;
+}>;
+/**
+ * Function for setting cwd during testing
+ */
+export declare function setCwd(path: string): void;