nx 20.8.4 → 22.7.7

package/src/executors/run-script/run-script.impl.js

@@ -1,57 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.default = default_1;
-const path = require("path");
-const package_manager_1 = require("../../utils/package-manager");
-const child_process_1 = require("child_process");
-const pseudo_terminal_1 = require("../../tasks-runner/pseudo-terminal");
-async function default_1(options, context) {
-    const pm = (0, package_manager_1.getPackageManagerCommand)();
-    try {
-        let command = pm.run(options.script, options.__unparsed__.join(' '));
-        let cwd = path.join(context.root, context.projectsConfigurations.projects[context.projectName].root);
-        let env = process.env;
-        // when running nx through npx with node_modules installed with npm, the path gets modified to include the full workspace path with the node_modules folder
-        // This causes issues when running in a pty process, so we filter out the node_modules paths from the PATH
-        // Since the command here will be run with the package manager script command, the path will be modified again within the PTY process itself.
-        let filteredPath = env.PATH?.split(path.delimiter)
-            .filter((p) => !p.startsWith(path.join(context.root, 'node_modules')))
-            .join(path.delimiter) ?? '';
-        env.PATH = filteredPath;
-        if (pseudo_terminal_1.PseudoTerminal.isSupported()) {
-            await ptyProcess(command, cwd, env);
-        }
-        else {
-            nodeProcess(command, cwd, env);
-        }
-        return { success: true };
-    }
-    catch (e) {
-        return { success: false };
-    }
-}
-function nodeProcess(command, cwd, env) {
-    (0, child_process_1.execSync)(command, {
-        stdio: ['inherit', 'inherit', 'inherit'],
-        cwd,
-        env,
-        windowsHide: false,
-    });
-}
-async function ptyProcess(command, cwd, env) {
-    const terminal = (0, pseudo_terminal_1.getPseudoTerminal)();
-    return new Promise((res, rej) => {
-        const cp = terminal.runCommand(command, { cwd, jsEnv: env });
-        cp.onExit((code) => {
-            if (code === 0) {
-                res();
-            }
-            else if (code >= 128) {
-                process.exit(code);
-            }
-            else {
-                rej();
-            }
-        });
-    });
-}

package/src/executors/run-script/schema.json

@@ -1,28 +0,0 @@
-{
-  "version": 2,
-  "title": "Run Script",
-  "description": "Run any NPM script of a project in the project's root directory.",
-  "type": "object",
-  "cli": "nx",
-  "outputCapture": "pipe",
-  "properties": {
-    "script": {
-      "type": "string",
-      "description": "An npm script name in the `package.json` file of the project (e.g., `build`)."
-    },
-    "__unparsed__": {
-      "hidden": true,
-      "type": "array",
-      "items": {
-        "type": "string"
-      },
-      "$default": {
-        "$source": "unparsed"
-      },
-      "x-priority": "internal"
-    }
-  },
-  "additionalProperties": true,
-  "required": ["script"],
-  "examplesFile": "../../../docs/run-script-examples.md"
-}

package/src/executors/utils/convert-nx-executor.js

@@ -1,83 +0,0 @@
-"use strict";
-/**
- * This is a copy of the @nx/devkit utility but this should not be used outside of the nx package
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.convertNxExecutor = convertNxExecutor;
-const nx_json_1 = require("../../config/nx-json");
-const retrieve_workspace_files_1 = require("../../project-graph/utils/retrieve-workspace-files");
-const project_configuration_utils_1 = require("../../project-graph/utils/project-configuration-utils");
-const get_plugins_1 = require("../../project-graph/plugins/get-plugins");
-/**
- * Convert an Nx Executor into an Angular Devkit Builder
- *
- * Use this to expose a compatible Angular Builder
- */
-function convertNxExecutor(executor) {
-    const builderFunction = (options, builderContext) => {
-        const promise = async () => {
-            const nxJsonConfiguration = (0, nx_json_1.readNxJson)(builderContext.workspaceRoot);
-            const plugins = await (0, get_plugins_1.getPlugins)();
-            const projectsConfigurations = {
-                version: 2,
-                projects: (0, project_configuration_utils_1.readProjectConfigurationsFromRootMap)((await (0, retrieve_workspace_files_1.retrieveProjectConfigurations)(plugins, builderContext.workspaceRoot, nxJsonConfiguration)).projects),
-            };
-            const context = {
-                root: builderContext.workspaceRoot,
-                projectName: builderContext.target.project,
-                targetName: builderContext.target.target,
-                target: builderContext.target.target,
-                configurationName: builderContext.target.configuration,
-                projectsConfigurations,
-                nxJsonConfiguration,
-                cwd: process.cwd(),
-                projectGraph: null,
-                taskGraph: null,
-                isVerbose: false,
-            };
-            return executor(options, context);
-        };
-        return toObservable(promise());
-    };
-    return require('@angular-devkit/architect').createBuilder(builderFunction);
-}
-function toObservable(promiseOrAsyncIterator) {
-    return new (require('rxjs').Observable)((subscriber) => {
-        promiseOrAsyncIterator
-            .then((value) => {
-            if (!value.next) {
-                subscriber.next(value);
-                subscriber.complete();
-            }
-            else {
-                let asyncIterator = value;
-                function recurse(iterator) {
-                    iterator
-                        .next()
-                        .then((result) => {
-                        if (!result.done) {
-                            subscriber.next(result.value);
-                            recurse(iterator);
-                        }
-                        else {
-                            if (result.value) {
-                                subscriber.next(result.value);
-                            }
-                            subscriber.complete();
-                        }
-                    })
-                        .catch((e) => {
-                        subscriber.error(e);
-                    });
-                }
-                recurse(asyncIterator);
-                return () => {
-                    asyncIterator.return();
-                };
-            }
-        })
-            .catch((err) => {
-            subscriber.error(err);
-        });
-    });
-}

package/src/generators/internal-utils/format-changed-files-with-prettier-if-available.d.ts

@@ -1,14 +0,0 @@
-import type { Tree } from '../tree';
-/**
- * Formats all the created or updated files using Prettier
- * @param tree - the file system tree
- */
-export declare function formatChangedFilesWithPrettierIfAvailable(tree: Tree, options?: {
-    silent?: boolean;
-}): Promise<void>;
-export declare function formatFilesWithPrettierIfAvailable(files: {
-    path: string;
-    content: string | Buffer;
-}[], root: string, options?: {
-    silent?: boolean;
-}): Promise<Map<string, string>>;

package/src/generators/internal-utils/format-changed-files-with-prettier-if-available.js

@@ -1,66 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.formatChangedFilesWithPrettierIfAvailable = formatChangedFilesWithPrettierIfAvailable;
-exports.formatFilesWithPrettierIfAvailable = formatFilesWithPrettierIfAvailable;
-const path = require("path");
-const is_using_prettier_1 = require("../../utils/is-using-prettier");
-/**
- * Formats all the created or updated files using Prettier
- * @param tree - the file system tree
- */
-async function formatChangedFilesWithPrettierIfAvailable(tree, options) {
-    const files = new Set(tree.listChanges().filter((file) => file.type !== 'DELETE'));
-    const results = await formatFilesWithPrettierIfAvailable(Array.from(files), tree.root, options);
-    for (const [path, content] of results) {
-        tree.write(path, content);
-    }
-}
-async function formatFilesWithPrettierIfAvailable(files, root, options) {
-    const results = new Map();
-    let prettier;
-    try {
-        prettier = await Promise.resolve().then(() => require('prettier'));
-        /**
-         * Even after we discovered prettier in node_modules, we need to be sure that the user is intentionally using prettier
-         * before proceeding to format with it.
-         */
-        if (!(0, is_using_prettier_1.isUsingPrettier)(root)) {
-            return results;
-        }
-    }
-    catch { }
-    if (!prettier) {
-        return results;
-    }
-    await Promise.all(Array.from(files).map(async (file) => {
-        try {
-            const systemPath = path.join(root, file.path);
-            let options = {
-                filepath: systemPath,
-            };
-            const resolvedOptions = await prettier.resolveConfig(systemPath, {
-                editorconfig: true,
-            });
-            if (!resolvedOptions) {
-                return;
-            }
-            options = {
-                ...options,
-                ...resolvedOptions,
-            };
-            const support = await prettier.getFileInfo(systemPath, options);
-            if (support.ignored || !support.inferredParser) {
-                return;
-            }
-            results.set(file.path, 
-            // In prettier v3 the format result is a promise
-            await prettier.format(file.content.toString('utf-8'), options));
-        }
-        catch (e) {
-            if (!options?.silent) {
-                console.warn(`Could not format ${file.path}. Error: "${e.message}"`);
-            }
-        }
-    }));
-    return results;
-}

package/src/generators/tree.js

@@ -1,309 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.FsTree = void 0;
-exports.flushChanges = flushChanges;
-exports.printChanges = printChanges;
-const node_fs_1 = require("node:fs");
-const logger_1 = require("../utils/logger");
-const output_1 = require("../utils/output");
-const path_1 = require("path");
-const chalk = require("chalk");
-class FsTree {
-    constructor(root, isVerbose, logOperationId) {
-        this.root = root;
-        this.isVerbose = isVerbose;
-        this.logOperationId = logOperationId;
-        this.recordedChanges = {};
-        /**
-         * Signifies if operations on the tree instance
-         * are allowed. Set to false after changes are written
-         * to disk, to prevent someone trying to use the tree to update
-         * files when the tree is no longer effective.
-         */
-        this.locked = false;
-    }
-    read(filePath, encoding) {
-        filePath = this.normalize(filePath);
-        try {
-            let content;
-            if (this.recordedChanges[this.rp(filePath)]) {
-                content = this.recordedChanges[this.rp(filePath)].content;
-            }
-            else {
-                content = this.fsReadFile(filePath);
-            }
-            return encoding ? content.toString(encoding) : content;
-        }
-        catch (e) {
-            if (this.isVerbose) {
-                logger_1.logger.error(e);
-            }
-            return null;
-        }
-    }
-    write(filePath, content, options) {
-        this.assertUnlocked();
-        filePath = this.normalize(filePath);
-        // Remove any recorded changes where a parent directory has been
-        // deleted when writing a new file within the directory.
-        let parent = (0, path_1.dirname)(this.rp(filePath));
-        while (parent !== '.') {
-            if (this.recordedChanges[parent]?.isDeleted) {
-                delete this.recordedChanges[parent];
-            }
-            parent = (0, path_1.dirname)(parent);
-        }
-        if (this.fsExists(this.rp(filePath)) &&
-            Buffer.from(content).equals(this.fsReadFile(filePath))) {
-            // Remove recorded change because the file has been restored to it's original contents
-            delete this.recordedChanges[this.rp(filePath)];
-            return;
-        }
-        try {
-            this.recordedChanges[this.rp(filePath)] = {
-                content: Buffer.from(content),
-                isDeleted: false,
-                options,
-            };
-        }
-        catch (e) {
-            if (this.isVerbose) {
-                logger_1.logger.error(e);
-            }
-        }
-    }
-    overwrite(filePath, content, options) {
-        filePath = this.normalize(filePath);
-        this.write(filePath, content, options);
-    }
-    delete(filePath) {
-        this.assertUnlocked();
-        filePath = this.normalize(filePath);
-        if (this.filesForDir(this.rp(filePath)).length > 0) {
-            this.filesForDir(this.rp(filePath)).forEach((f) => (this.recordedChanges[f] = { content: null, isDeleted: true }));
-        }
-        this.recordedChanges[this.rp(filePath)] = {
-            content: null,
-            isDeleted: true,
-        };
-        // Delete directory when is not root and there are no children
-        if (filePath !== '' &&
-            this.children((0, path_1.dirname)(this.rp(filePath))).length < 1) {
-            this.delete((0, path_1.dirname)(this.rp(filePath)));
-        }
-    }
-    exists(filePath) {
-        filePath = this.normalize(filePath);
-        try {
-            if (this.recordedChanges[this.rp(filePath)]) {
-                return !this.recordedChanges[this.rp(filePath)].isDeleted;
-            }
-            else if (this.filesForDir(this.rp(filePath)).length > 0) {
-                return true;
-            }
-            else {
-                return this.fsExists(filePath);
-            }
-        }
-        catch {
-            return false;
-        }
-    }
-    rename(from, to) {
-        this.assertUnlocked();
-        from = this.normalize(from);
-        to = this.normalize(to);
-        if (from === to) {
-            return;
-        }
-        if (this.isFile(from)) {
-            const content = this.read(this.rp(from));
-            this.write(this.rp(to), content);
-            this.delete(this.rp(from));
-        }
-        else {
-            for (const child of this.children(from)) {
-                this.rename((0, path_1.join)(from, child), (0, path_1.join)(to, child));
-            }
-        }
-    }
-    isFile(filePath) {
-        filePath = this.normalize(filePath);
-        try {
-            if (this.recordedChanges[this.rp(filePath)]) {
-                return !this.recordedChanges[this.rp(filePath)].isDeleted;
-            }
-            else {
-                return this.fsIsFile(filePath);
-            }
-        }
-        catch {
-            return false;
-        }
-    }
-    children(dirPath) {
-        dirPath = this.normalize(dirPath);
-        let res = this.fsReadDir(dirPath);
-        res = [...res, ...this.directChildrenOfDir(this.rp(dirPath))];
-        res = res.filter((q) => {
-            const r = this.recordedChanges[this.normalize((0, path_1.join)(this.rp(dirPath), q))];
-            return !r?.isDeleted;
-        });
-        // Dedupe
-        return Array.from(new Set(res));
-    }
-    listChanges() {
-        const res = [];
-        Object.keys(this.recordedChanges).forEach((f) => {
-            if (this.recordedChanges[f].isDeleted) {
-                if (this.fsExists(f)) {
-                    res.push({ path: f, type: 'DELETE', content: null });
-                }
-            }
-            else {
-                if (this.fsExists(f)) {
-                    res.push({
-                        path: f,
-                        type: 'UPDATE',
-                        content: this.recordedChanges[f].content,
-                        options: this.recordedChanges[f].options,
-                    });
-                }
-                else {
-                    res.push({
-                        path: f,
-                        type: 'CREATE',
-                        content: this.recordedChanges[f].content,
-                        options: this.recordedChanges[f].options,
-                    });
-                }
-            }
-        });
-        return res;
-    }
-    changePermissions(filePath, mode) {
-        this.assertUnlocked();
-        filePath = this.normalize(filePath);
-        const filePathChangeKey = this.rp(filePath);
-        if (this.recordedChanges[filePathChangeKey]) {
-            if (this.recordedChanges[filePathChangeKey].isDeleted) {
-                throw new Error(`Cannot change permissions of deleted file ${filePath}.`);
-            }
-            this.recordedChanges[filePathChangeKey].options = { mode };
-        }
-        else if (!this.fsExists(filePath)) {
-            throw new Error(`Cannot change permissions of non-existing file ${filePath}.`);
-        }
-        else if (!this.fsIsFile(filePath)) {
-            // To fully support directories we'd need to change how we store
-            // changes to keep a record of directories so we can associate
-            // permissions to them.
-            throw new Error(`Cannot change permissions of non-file ${filePath}.`);
-        }
-        else {
-            this.recordedChanges[filePathChangeKey] = {
-                content: this.fsReadFile(filePath),
-                isDeleted: false,
-                options: { mode },
-            };
-        }
-    }
-    // Marks FsTree as final.
-    lock() {
-        this.locked = true;
-    }
-    assertUnlocked() {
-        if (this.locked) {
-            output_1.output.error({
-                title: `File changes have already been written to disk. Further changes were attempted ${this.logOperationId ? ` while running ${this.logOperationId}.` : '.'}`,
-                bodyLines: [
-                    'The file system can no longer be modified. This commonly happens when a generator attempts to make further changes in its callback, or an asynchronous operation is still running after the generator completes.',
-                ],
-            });
-            throw new Error('Tree changed after commit to disk.');
-        }
-    }
-    normalize(path) {
-        return (0, path_1.relative)(this.root, (0, path_1.join)(this.root, path)).split(path_1.sep).join('/');
-    }
-    fsReadDir(dirPath) {
-        try {
-            return (0, node_fs_1.readdirSync)((0, path_1.join)(this.root, dirPath));
-        }
-        catch {
-            return [];
-        }
-    }
-    fsIsFile(filePath) {
-        const stat = (0, node_fs_1.statSync)((0, path_1.join)(this.root, filePath));
-        return stat.isFile();
-    }
-    fsReadFile(filePath) {
-        return (0, node_fs_1.readFileSync)((0, path_1.join)(this.root, filePath));
-    }
-    fsExists(filePath) {
-        try {
-            const stat = (0, node_fs_1.statSync)((0, path_1.join)(this.root, filePath));
-            return stat.isFile() || stat.isDirectory();
-        }
-        catch {
-            return false;
-        }
-    }
-    filesForDir(path) {
-        return Object.keys(this.recordedChanges).filter((f) => f.startsWith(`${path}/`) && !this.recordedChanges[f].isDeleted);
-    }
-    directChildrenOfDir(path) {
-        const res = {};
-        if (path === '') {
-            return Object.keys(this.recordedChanges).map((file) => file.split('/')[0]);
-        }
-        Object.keys(this.recordedChanges).forEach((f) => {
-            if (f.startsWith(`${path}/`)) {
-                // Remove the current folder's path from the directory
-                const file = f.substring(path.length + 1);
-                // Split the path on segments, and take the first one
-                const basePath = file.split('/')[0];
-                // Mark it as a child of the current directory
-                res[basePath] = true;
-            }
-        });
-        return Object.keys(res);
-    }
-    rp(pp) {
-        return pp.startsWith('/') ? pp.substring(1) : pp;
-    }
-}
-exports.FsTree = FsTree;
-function flushChanges(root, fileChanges) {
-    fileChanges.forEach((f) => {
-        const fpath = (0, path_1.join)(root, f.path);
-        if (f.type === 'CREATE') {
-            (0, node_fs_1.mkdirSync)((0, path_1.dirname)(fpath), { recursive: true });
-            (0, node_fs_1.writeFileSync)(fpath, f.content);
-            if (f.options?.mode)
-                (0, node_fs_1.chmodSync)(fpath, f.options.mode);
-        }
-        else if (f.type === 'UPDATE') {
-            (0, node_fs_1.writeFileSync)(fpath, f.content);
-            if (f.options?.mode)
-                (0, node_fs_1.chmodSync)(fpath, f.options.mode);
-        }
-        else if (f.type === 'DELETE') {
-            (0, node_fs_1.rmSync)(fpath, { recursive: true, force: true });
-        }
-    });
-}
-function printChanges(fileChanges, indent = '') {
-    fileChanges.forEach((f) => {
-        if (f.type === 'CREATE') {
-            console.log(`${indent}${chalk.green('CREATE')} ${f.path}`);
-        }
-        else if (f.type === 'UPDATE') {
-            console.log(`${indent}${chalk.white('UPDATE')} ${f.path}`);
-        }
-        else if (f.type === 'DELETE') {
-            console.log(`${indent}${chalk.yellow('DELETE')} ${f.path}`);
-        }
-    });
-}

package/src/generators/utils/nx-json.d.ts

@@ -1,11 +0,0 @@
-import type { NxJsonConfiguration } from '../../config/nx-json';
-import type { Tree } from '../tree';
-/**
- * @deprecated You must pass a {@link Tree}. This will be removed in Nx 21.
- */
-export declare function readNxJson(): NxJsonConfiguration | null;
-export declare function readNxJson(tree: Tree): NxJsonConfiguration | null;
-/**
- * Update nx.json
- */
-export declare function updateNxJson(tree: Tree, nxJson: NxJsonConfiguration): void;

package/src/generators/utils/nx-json.js

@@ -1,58 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.readNxJson = readNxJson;
-exports.updateNxJson = updateNxJson;
-const path_1 = require("path");
-const json_1 = require("./json");
-const nx_json_1 = require("../../config/nx-json");
-/**
- * Reads nx.json
- */
-function readNxJson(tree) {
-    if (tree) {
-        if (!tree.exists('nx.json')) {
-            return null;
-        }
-        let nxJson = (0, json_1.readJson)(tree, 'nx.json');
-        if (nxJson.extends) {
-            nxJson = { ...readNxJsonExtends(tree, nxJson.extends), ...nxJson };
-        }
-        return nxJson;
-    }
-    else {
-        return (0, nx_json_1.readNxJson)();
-    }
-}
-/**
- * Update nx.json
- */
-function updateNxJson(tree, nxJson) {
-    if (tree.exists('nx.json')) {
-        (0, json_1.updateJson)(tree, 'nx.json', (json) => {
-            if (json.extends) {
-                const nxJsonExtends = readNxJsonExtends(tree, json.extends);
-                const changedPropsOfNxJson = {};
-                Object.keys(nxJson).forEach((prop) => {
-                    if (JSON.stringify(nxJson[prop], null, 2) !=
-                        JSON.stringify(nxJsonExtends[prop], null, 2)) {
-                        changedPropsOfNxJson[prop] = nxJson[prop];
-                    }
-                });
-                return changedPropsOfNxJson;
-            }
-            else {
-                return nxJson;
-            }
-        });
-    }
-}
-function readNxJsonExtends(tree, extendsPath) {
-    try {
-        return (0, json_1.readJson)(tree, (0, path_1.relative)(tree.root, require.resolve(extendsPath, {
-            paths: [tree.root],
-        })));
-    }
-    catch (e) {
-        throw new Error(`Unable to resolve nx.json extends. Error: ${e.message}`);
-    }
-}