nx 20.3.0 → 20.4.0-beta.0

package/src/project-graph/plugins/loaded-nx-plugin.js

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LoadedNxPlugin = void 0;
+const error_types_1 = require("../error-types");
+const utils_1 = require("./utils");
+class LoadedNxPlugin {
+    constructor(plugin, pluginDefinition) {
+        this.name = plugin.name;
+        if (typeof pluginDefinition !== 'string') {
+            this.options = pluginDefinition.options;
+            this.include = pluginDefinition.include;
+            this.exclude = pluginDefinition.exclude;
+        }
+        if (plugin.createNodes && !plugin.createNodesV2) {
+            this.createNodes = [
+                plugin.createNodes[0],
+                (configFiles, context) => (0, utils_1.createNodesFromFiles)(plugin.createNodes[1], configFiles, this.options, context).then((results) => results.map((r) => [this.name, r[0], r[1]])),
+            ];
+        }
+        if (plugin.createNodesV2) {
+            this.createNodes = [
+                plugin.createNodesV2[0],
+                async (configFiles, context) => {
+                    const result = await plugin.createNodesV2[1](configFiles, this.options, context);
+                    return result.map((r) => [this.name, r[0], r[1]]);
+                },
+            ];
+        }
+        if (this.createNodes) {
+            const inner = this.createNodes[1];
+            this.createNodes[1] = async (...args) => {
+                performance.mark(`${plugin.name}:createNodes - start`);
+                try {
+                    return await inner(...args);
+                }
+                catch (e) {
+                    if ((0, error_types_1.isAggregateCreateNodesError)(e)) {
+                        throw e;
+                    }
+                    // The underlying plugin errored out. We can't know any partial results.
+                    throw new error_types_1.AggregateCreateNodesError([[null, e]], []);
+                }
+                finally {
+                    performance.mark(`${plugin.name}:createNodes - end`);
+                    performance.measure(`${plugin.name}:createNodes`, `${plugin.name}:createNodes - start`, `${plugin.name}:createNodes - end`);
+                }
+            };
+        }
+        if (plugin.createDependencies) {
+            this.createDependencies = async (context) => plugin.createDependencies(this.options, context);
+        }
+        if (plugin.createMetadata) {
+            this.createMetadata = async (graph, context) => plugin.createMetadata(graph, this.options, context);
+        }
+    }
+}
+exports.LoadedNxPlugin = LoadedNxPlugin;

package/src/project-graph/plugins/resolve-plugin.d.ts

@@ -0,0 +1,15 @@
+import type { ProjectConfiguration } from '../../config/workspace-json-project-json';
+export declare function resolveNxPlugin(moduleName: string, root: string, paths: string[]): Promise<{
+    pluginPath: string;
+    name: any;
+    shouldRegisterTSTranspiler: boolean;
+}>;
+export declare function resolveLocalNxPlugin(importPath: string, projects: Record<string, ProjectConfiguration>, root?: string): {
+    path: string;
+    projectConfig: ProjectConfiguration;
+} | null;
+export declare function getPluginPathAndName(moduleName: string, paths: string[], projects: Record<string, ProjectConfiguration>, root: string): {
+    pluginPath: string;
+    name: any;
+    shouldRegisterTSTranspiler: boolean;
+};

package/src/project-graph/plugins/{loader.js → resolve-plugin.js}

@@ -1,135 +1,29 @@
 "use strict";
-// This file contains methods and utilities that should **only** be used by the plugin worker.
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.unregisterPluginTSTranspiler = void 0;
-exports.readPluginPackageJson = readPluginPackageJson;
+exports.resolveNxPlugin = resolveNxPlugin;
 exports.resolveLocalNxPlugin = resolveLocalNxPlugin;
-exports.registerPluginTSTranspiler = registerPluginTSTranspiler;
 exports.getPluginPathAndName = getPluginPathAndName;
-exports.loadNxPlugin = loadNxPlugin;
-exports.resolveNxPlugin = resolveNxPlugin;
-exports.loadNxPluginAsync = loadNxPluginAsync;
-const posix_1 = require("node:path/posix");
-const installation_directory_1 = require("../../utils/installation-directory");
-const package_json_1 = require("../../utils/package-json");
+const path = require("node:path");
+const node_fs_1 = require("node:fs");
+const packages_1 = require("../../plugins/js/utils/packages");
 const fileutils_1 = require("../../utils/fileutils");
+const logger_1 = require("../../utils/logger");
+const path_1 = require("../../utils/path");
 const workspace_root_1 = require("../../utils/workspace-root");
-const node_fs_1 = require("node:fs");
-const register_1 = require("../../plugins/js/utils/register");
 const find_project_for_path_1 = require("../utils/find-project-for-path");
-const path_1 = require("../../utils/path");
-const logger_1 = require("../../utils/logger");
-const node_path_1 = require("node:path");
 const retrieve_workspace_files_1 = require("../utils/retrieve-workspace-files");
-const error_types_1 = require("../error-types");
-const path = require("node:path/posix");
-const typescript_1 = require("../../plugins/js/utils/typescript");
-const load_resolved_plugin_1 = require("./load-resolved-plugin");
-const packages_1 = require("../../plugins/js/utils/packages");
-function readPluginPackageJson(pluginName, projects, paths = (0, installation_directory_1.getNxRequirePaths)()) {
+let projectsWithoutInference;
+async function resolveNxPlugin(moduleName, root, paths) {
     try {
-        const result = (0, package_json_1.readModulePackageJsonWithoutFallbacks)(pluginName, paths);
-        return {
-            json: result.packageJson,
-            path: result.path,
-        };
-    }
-    catch (e) {
-        if (e.code === 'MODULE_NOT_FOUND') {
-            const localPluginPath = resolveLocalNxPlugin(pluginName, projects);
-            if (localPluginPath) {
-                const localPluginPackageJson = path.join(localPluginPath.path, 'package.json');
-                if (!exports.unregisterPluginTSTranspiler) {
-                    registerPluginTSTranspiler();
-                }
-                return {
-                    path: localPluginPackageJson,
-                    json: (0, fileutils_1.readJsonFile)(localPluginPackageJson),
-                };
-            }
-        }
-        throw e;
-    }
-}
-function resolveLocalNxPlugin(importPath, projects, root = workspace_root_1.workspaceRoot) {
-    return lookupLocalPlugin(importPath, projects, root);
-}
-exports.unregisterPluginTSTranspiler = null;
-/**
- * Register swc-node or ts-node if they are not currently registered
- * with some default settings which work well for Nx plugins.
- */
-function registerPluginTSTranspiler() {
-    // Get the first tsconfig that matches the allowed set
-    const tsConfigName = [
-        (0, posix_1.join)(workspace_root_1.workspaceRoot, 'tsconfig.base.json'),
-        (0, posix_1.join)(workspace_root_1.workspaceRoot, 'tsconfig.json'),
-    ].find((x) => (0, node_fs_1.existsSync)(x));
-    if (!tsConfigName) {
-        return;
-    }
-    const tsConfig = tsConfigName
-        ? (0, typescript_1.readTsConfig)(tsConfigName)
-        : {};
-    const cleanupFns = [
-        (0, register_1.registerTsConfigPaths)(tsConfigName),
-        (0, register_1.registerTranspiler)({
-            experimentalDecorators: true,
-            emitDecoratorMetadata: true,
-            ...tsConfig.options,
-        }, tsConfig.raw),
-    ];
-    exports.unregisterPluginTSTranspiler = () => {
-        cleanupFns.forEach((fn) => fn?.());
-    };
-}
-function lookupLocalPlugin(importPath, projects, root = workspace_root_1.workspaceRoot) {
-    const projectConfig = findNxProjectForImportPath(importPath, projects, root);
-    if (!projectConfig) {
-        return null;
-    }
-    return { path: path.join(root, projectConfig.root), projectConfig };
-}
-let packageEntryPointsToProjectMap;
-function findNxProjectForImportPath(importPath, projects, root = workspace_root_1.workspaceRoot) {
-    const tsConfigPaths = readTsConfigPaths(root);
-    const possibleTsPaths = tsConfigPaths[importPath]?.map((p) => (0, path_1.normalizePath)(path.relative(root, path.join(root, p)))) ?? [];
-    const projectRootMappings = new Map();
-    if (possibleTsPaths.length) {
-        const projectNameMap = new Map();
-        for (const projectRoot in projects) {
-            const project = projects[projectRoot];
-            projectRootMappings.set(project.root, project.name);
-            projectNameMap.set(project.name, project);
-        }
-        for (const tsConfigPath of possibleTsPaths) {
-            const nxProject = (0, find_project_for_path_1.findProjectForPath)(tsConfigPath, projectRootMappings);
-            if (nxProject) {
-                return projectNameMap.get(nxProject);
-            }
-        }
-    }
-    packageEntryPointsToProjectMap ??=
-        (0, packages_1.getPackageEntryPointsToProjectMap)(projects);
-    if (packageEntryPointsToProjectMap[importPath]) {
-        return packageEntryPointsToProjectMap[importPath];
+        require.resolve(moduleName);
     }
-    logger_1.logger.verbose('Unable to find local plugin', possibleTsPaths, projectRootMappings);
-    throw new Error('Unable to resolve local plugin with import path ' + importPath);
-}
-let tsconfigPaths;
-function readTsConfigPaths(root = workspace_root_1.workspaceRoot) {
-    if (!tsconfigPaths) {
-        const tsconfigPath = ['tsconfig.base.json', 'tsconfig.json']
-            .map((x) => path.join(root, x))
-            .filter((x) => (0, node_fs_1.existsSync)(x))[0];
-        if (!tsconfigPath) {
-            throw new Error('unable to find tsconfig.base.json or tsconfig.json');
-        }
-        const { compilerOptions } = (0, fileutils_1.readJsonFile)(tsconfigPath);
-        tsconfigPaths = compilerOptions?.paths;
+    catch {
+        // If a plugin cannot be resolved, we will need projects to resolve it
+        projectsWithoutInference ??=
+            await (0, retrieve_workspace_files_1.retrieveProjectConfigurationsWithoutPluginInference)(root);
     }
-    return tsconfigPaths ?? {};
+    const { pluginPath, name, shouldRegisterTSTranspiler } = getPluginPathAndName(moduleName, paths, projectsWithoutInference, root);
+    return { pluginPath, name, shouldRegisterTSTranspiler };
 }
 function readPluginMainFromProjectConfiguration(plugin) {
     const { main } = Object.values(plugin.targets).find((x) => [
@@ -144,6 +38,9 @@ function readPluginMainFromProjectConfiguration(plugin) {
         {};
     return main;
 }
+function resolveLocalNxPlugin(importPath, projects, root = workspace_root_1.workspaceRoot) {
+    return lookupLocalPlugin(importPath, projects, root);
+}
 function getPluginPathAndName(moduleName, paths, projects, root) {
     let pluginPath;
     let shouldRegisterTSTranspiler = false;
@@ -172,43 +69,57 @@ function getPluginPathAndName(moduleName, paths, projects, root) {
         }
     }
     const packageJsonPath = path.join(pluginPath, 'package.json');
-    const { name } = !['.ts', '.js'].some((x) => (0, node_path_1.extname)(moduleName) === x) && // Not trying to point to a ts or js file
+    const { name } = !['.ts', '.js'].some((x) => path.extname(moduleName) === x) && // Not trying to point to a ts or js file
         (0, node_fs_1.existsSync)(packageJsonPath) // plugin has a package.json
         ? (0, fileutils_1.readJsonFile)(packageJsonPath) // read name from package.json
         : { name: moduleName };
     return { pluginPath, name, shouldRegisterTSTranspiler };
 }
-let projectsWithoutInference;
-function loadNxPlugin(plugin, root) {
-    return [
-        loadNxPluginAsync(plugin, (0, installation_directory_1.getNxRequirePaths)(root), root),
-        () => { },
-    ];
+function lookupLocalPlugin(importPath, projects, root = workspace_root_1.workspaceRoot) {
+    const projectConfig = findNxProjectForImportPath(importPath, projects, root);
+    if (!projectConfig) {
+        return null;
+    }
+    return { path: path.join(root, projectConfig.root), projectConfig };
 }
-async function resolveNxPlugin(moduleName, root, paths) {
-    try {
-        require.resolve(moduleName);
+let packageEntryPointsToProjectMap;
+function findNxProjectForImportPath(importPath, projects, root = workspace_root_1.workspaceRoot) {
+    const tsConfigPaths = readTsConfigPaths(root);
+    const possibleTsPaths = tsConfigPaths[importPath]?.map((p) => (0, path_1.normalizePath)(path.relative(root, path.join(root, p)))) ?? [];
+    const projectRootMappings = new Map();
+    if (possibleTsPaths.length) {
+        const projectNameMap = new Map();
+        for (const projectRoot in projects) {
+            const project = projects[projectRoot];
+            projectRootMappings.set(project.root, project.name);
+            projectNameMap.set(project.name, project);
+        }
+        for (const tsConfigPath of possibleTsPaths) {
+            const nxProject = (0, find_project_for_path_1.findProjectForPath)(tsConfigPath, projectRootMappings);
+            if (nxProject) {
+                return projectNameMap.get(nxProject);
+            }
+        }
     }
-    catch {
-        // If a plugin cannot be resolved, we will need projects to resolve it
-        projectsWithoutInference ??=
-            await (0, retrieve_workspace_files_1.retrieveProjectConfigurationsWithoutPluginInference)(root);
+    packageEntryPointsToProjectMap ??=
+        (0, packages_1.getPackageEntryPointsToProjectMap)(projects);
+    if (packageEntryPointsToProjectMap[importPath]) {
+        return packageEntryPointsToProjectMap[importPath];
     }
-    const { pluginPath, name, shouldRegisterTSTranspiler } = getPluginPathAndName(moduleName, paths, projectsWithoutInference, root);
-    return { pluginPath, name, shouldRegisterTSTranspiler };
+    logger_1.logger.verbose('Unable to find local plugin', possibleTsPaths, projectRootMappings);
+    throw new Error('Unable to resolve local plugin with import path ' + importPath);
 }
-async function loadNxPluginAsync(pluginConfiguration, paths, root) {
-    const moduleName = typeof pluginConfiguration === 'string'
-        ? pluginConfiguration
-        : pluginConfiguration.plugin;
-    try {
-        const { pluginPath, name, shouldRegisterTSTranspiler } = await resolveNxPlugin(moduleName, root, paths);
-        if (shouldRegisterTSTranspiler) {
-            registerPluginTSTranspiler();
+let tsconfigPaths;
+function readTsConfigPaths(root = workspace_root_1.workspaceRoot) {
+    if (!tsconfigPaths) {
+        const tsconfigPath = ['tsconfig.base.json', 'tsconfig.json']
+            .map((x) => path.join(root, x))
+            .filter((x) => (0, node_fs_1.existsSync)(x))[0];
+        if (!tsconfigPath) {
+            throw new Error('unable to find tsconfig.base.json or tsconfig.json');
         }
-        return (0, load_resolved_plugin_1.loadResolvedNxPluginAsync)(pluginConfiguration, pluginPath, name);
-    }
-    catch (e) {
-        throw new error_types_1.LoadPluginError(moduleName, e);
+        const { compilerOptions } = (0, fileutils_1.readJsonFile)(tsconfigPath);
+        tsconfigPaths = compilerOptions?.paths;
     }
+    return tsconfigPaths ?? {};
 }

package/src/project-graph/plugins/transpiler.d.ts

@@ -0,0 +1,8 @@
+export declare let unregisterPluginTSTranspiler: (() => void) | null;
+/**
+ * Register swc-node or ts-node if they are not currently registered
+ * with some default settings which work well for Nx plugins.
+ */
+export declare function registerPluginTSTranspiler(): void;
+export declare function pluginTranspilerIsRegistered(): boolean;
+export declare function cleanupPluginTSTranspiler(): void;

package/src/project-graph/plugins/transpiler.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.unregisterPluginTSTranspiler = void 0;
+exports.registerPluginTSTranspiler = registerPluginTSTranspiler;
+exports.pluginTranspilerIsRegistered = pluginTranspilerIsRegistered;
+exports.cleanupPluginTSTranspiler = cleanupPluginTSTranspiler;
+const node_fs_1 = require("node:fs");
+const posix_1 = require("node:path/posix");
+const workspace_root_1 = require("../../utils/workspace-root");
+const register_1 = require("../../plugins/js/utils/register");
+const typescript_1 = require("../../plugins/js/utils/typescript");
+exports.unregisterPluginTSTranspiler = null;
+/**
+ * Register swc-node or ts-node if they are not currently registered
+ * with some default settings which work well for Nx plugins.
+ */
+function registerPluginTSTranspiler() {
+    // Get the first tsconfig that matches the allowed set
+    const tsConfigName = [
+        (0, posix_1.join)(workspace_root_1.workspaceRoot, 'tsconfig.base.json'),
+        (0, posix_1.join)(workspace_root_1.workspaceRoot, 'tsconfig.json'),
+    ].find((x) => (0, node_fs_1.existsSync)(x));
+    if (!tsConfigName) {
+        return;
+    }
+    const tsConfig = tsConfigName
+        ? (0, typescript_1.readTsConfig)(tsConfigName)
+        : {};
+    const cleanupFns = [
+        (0, register_1.registerTsConfigPaths)(tsConfigName),
+        (0, register_1.registerTranspiler)({
+            experimentalDecorators: true,
+            emitDecoratorMetadata: true,
+            ...tsConfig.options,
+        }, tsConfig.raw),
+    ];
+    exports.unregisterPluginTSTranspiler = () => {
+        cleanupFns.forEach((fn) => fn?.());
+    };
+}
+function pluginTranspilerIsRegistered() {
+    return exports.unregisterPluginTSTranspiler !== null;
+}
+function cleanupPluginTSTranspiler() {
+    (0, exports.unregisterPluginTSTranspiler)?.();
+    exports.unregisterPluginTSTranspiler = null;
+}

package/src/project-graph/project-graph.js

@@ -135,9 +135,6 @@ function handleProjectGraphError(opts, e) {
         const isVerbose = process.env.NX_VERBOSE_LOGGING === 'true';
         if (e instanceof error_types_1.ProjectGraphError) {
             let title = e.message;
-            if (isVerbose) {
-                title += ' See errors below.';
-            }
             const bodyLines = isVerbose
                 ? [e.stack]
                 : ['Pass --verbose to see the stacktraces.'];

package/src/project-graph/utils/project-configuration-utils.d.ts

@@ -1,7 +1,7 @@
 import { NxJsonConfiguration, TargetDefaults } from '../../config/nx-json';
 import { ProjectGraphExternalNode } from '../../config/project-graph';
 import { ProjectConfiguration, ProjectMetadata, TargetConfiguration, TargetMetadata } from '../../config/workspace-json-project-json';
-import { LoadedNxPlugin } from '../plugins/internal-api';
+import { LoadedNxPlugin } from '../plugins/loaded-nx-plugin';
 export type SourceInformation = [file: string | null, plugin: string];
 export type ConfigurationSourceMaps = Record<string, Record<string, SourceInformation>>;
 export declare function mergeProjectConfigurationIntoRootMap(projectRootMap: Record<string, ProjectConfiguration>, project: ProjectConfiguration, configurationSourceMaps?: ConfigurationSourceMaps, sourceInformation?: SourceInformation, skipTargetNormalization?: boolean): void;

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

@@ -260,28 +260,12 @@ plugins) {
             workspaceRoot: root,
         })
             .catch((e) => {
-            const errorBodyLines = [
-                `An error occurred while processing files for the ${pluginName} plugin.`,
-            ];
             const error = (0, error_types_1.isAggregateCreateNodesError)(e)
                 ? // This is an expected error if something goes wrong while processing files.
                     e
                 : // This represents a single plugin erroring out with a hard error.
                     new error_types_1.AggregateCreateNodesError([[null, e]], []);
-            const innerErrors = error.errors;
-            for (const [file, e] of innerErrors) {
-                if (file) {
-                    errorBodyLines.push(`  - ${file}: ${e.message}`);
-                }
-                else {
-                    errorBodyLines.push(`  - ${e.message}`);
-                }
-                if (e.stack) {
-                    const innerStackTrace = '    ' + e.stack.split('\n')?.join('\n    ');
-                    errorBodyLines.push(innerStackTrace);
-                }
-            }
-            error.stack = errorBodyLines.join('\n');
+            (0, error_types_1.formatAggregateCreateNodesError)(error, pluginName);
             // This represents a single plugin erroring out with a hard error.
             errors.push(error);
             // The plugin didn't return partial results, so we return an empty array.

package/src/project-graph/utils/retrieve-workspace-files.d.ts

@@ -1,7 +1,7 @@
 import { ProjectConfiguration } from '../../config/workspace-json-project-json';
 import { NxJsonConfiguration } from '../../config/nx-json';
 import { ConfigurationResult } from './project-configuration-utils';
-import { LoadedNxPlugin } from '../plugins/internal-api';
+import { LoadedNxPlugin } from '../plugins/loaded-nx-plugin';
 /**
  * Walks the workspace directory to create the `projectFileMap`, `ProjectConfigurations` and `allWorkspaceFiles`
  * @throws

package/src/tasks-runner/cache.d.ts

@@ -21,6 +21,7 @@ export declare class DbCache {
     private isVerbose;
     constructor(options: {
         nxCloudRemoteCache: RemoteCache;
+        skipRemoteCache?: boolean;
     });
     init(): Promise<void>;
     get(task: Task): Promise<CachedResult | null>;

package/src/tasks-runner/cache.js

@@ -61,6 +61,7 @@ function getCache(options) {
         ? new DbCache({
             // Remove this in Nx 21
             nxCloudRemoteCache: (0, nx_cloud_utils_1.isNxCloudUsed)(nxJson) ? options.remoteCache : null,
+            skipRemoteCache: options.skipRemoteCache,
         })
         : new Cache(options);
 }
@@ -132,6 +133,15 @@ class DbCache {
         return this.remoteCachePromise;
     }
     async _getRemoteCache() {
+        if (this.options.skipRemoteCache) {
+            output_1.output.warn({
+                title: 'Remote Cache Disabled',
+                bodyLines: [
+                    'Nx will continue running, but nothing will be written or read from the remote cache.',
+                ],
+            });
+            return null;
+        }
         const nxJson = (0, nx_json_1.readNxJson)();
         if ((0, nx_cloud_utils_1.isNxCloudUsed)(nxJson)) {
             const options = (0, get_cloud_options_1.getCloudOptions)();
@@ -211,6 +221,14 @@ class Cache {
         this.cachePath = this.createCacheDir();
         this.terminalOutputsDir = this.createTerminalOutputsDir();
         this._currentMachineId = null;
+        if (this.options.skipRemoteCache) {
+            output_1.output.warn({
+                title: 'Remote Cache Disabled',
+                bodyLines: [
+                    'Nx will continue running, but nothing will be written or read from the remote cache.',
+                ],
+            });
+        }
     }
     removeOldCacheRecords() {
         /**
@@ -255,7 +273,7 @@ class Cache {
             await this.assertLocalCacheValidity(task);
             return { ...res, remote: false };
         }
-        else if (this.options.remoteCache) {
+        else if (this.options.remoteCache && !this.options.skipRemoteCache) {
             // didn't find it locally but we have a remote cache
             // attempt remote cache
             await this.options.remoteCache.retrieve(task.hash, this.cachePath);
@@ -295,7 +313,7 @@ class Cache {
             await (0, promises_1.writeFile)((0, path_1.join)(td, 'code'), code.toString());
             await (0, promises_1.writeFile)((0, path_1.join)(td, 'source'), await this.currentMachineId());
             await (0, promises_1.writeFile)(tdCommit, 'true');
-            if (this.options.remoteCache) {
+            if (this.options.remoteCache && !this.options.skipRemoteCache) {
                 await this.options.remoteCache.store(task.hash, this.cachePath);
             }
             if (terminalOutput) {

package/src/tasks-runner/default-tasks-runner.d.ts

@@ -20,6 +20,7 @@ export interface DefaultTasksRunnerOptions {
     lifeCycle: LifeCycle;
     captureStderr?: boolean;
     skipNxCache?: boolean;
+    skipRemoteCache?: boolean;
     batch?: boolean;
 }
 export declare const defaultTasksRunner: TasksRunner<DefaultTasksRunnerOptions>;

package/src/utils/command-line-utils.d.ts

@@ -27,6 +27,7 @@ export interface NxArgs {
     select?: string;
     graph?: string | boolean;
     skipNxCache?: boolean;
+    skipRemoteCache?: boolean;
     outputStyle?: string;
     nxBail?: boolean;
     nxIgnoreCycles?: boolean;

package/src/utils/command-line-utils.js

@@ -113,7 +113,14 @@ function splitArgsIntoNxArgsAndOverrides(args, mode, options = { printWarnings:
         nxArgs.exclude = args.exclude.split(',');
     }
     if (!nxArgs.skipNxCache) {
-        nxArgs.skipNxCache = process.env.NX_SKIP_NX_CACHE === 'true';
+        nxArgs.skipNxCache =
+            process.env.NX_SKIP_NX_CACHE === 'true' ||
+                process.env.NX_DISABLE_NX_CACHE === 'true';
+    }
+    if (!nxArgs.skipRemoteCache) {
+        nxArgs.skipRemoteCache =
+            process.env.NX_DISABLE_REMOTE_CACHE === 'true' ||
+                process.env.NX_SKIP_REMOTE_CACHE === 'true';
     }
     normalizeNxArgsRunner(nxArgs, nxJson, options);
     nxArgs['parallel'] = (0, shared_options_1.readParallelFromArgsAndEnv)(args);

package/src/utils/delayed-spinner.js

@@ -21,13 +21,13 @@ class DelayedSpinner {
         const delay = SHOULD_SHOW_SPINNERS ? opts.delay : opts.ciDelay;
         this.timeouts.push(setTimeout(() => {
             this.ready = true;
+            this.lastMessage = message;
             if (!SHOULD_SHOW_SPINNERS) {
                 console.warn(this.lastMessage);
             }
             else {
                 this.spinner = ora(this.lastMessage).start();
             }
-            this.lastMessage = message;
         }, delay).unref());
     }
     /**

package/src/utils/find-matching-projects.js

@@ -112,6 +112,17 @@ function addMatchingProjectsByName(projectNames, projects, pattern, matchedProje
         return;
     }
     if (!(0, globs_1.isGlobPattern)(pattern.value)) {
+        // Custom regex that is basically \b without underscores, so "foo" pattern matches "foo_bar".
+        const regex = new RegExp(`(?<![a-zA-Z0-9])${pattern.value}(?![a-zA-Z0-9])`, 'i');
+        const matchingProjects = Object.keys(projects).filter((name) => regex.test(name));
+        for (const projectName of matchingProjects) {
+            if (pattern.exclude) {
+                matchedProjects.delete(projectName);
+            }
+            else {
+                matchedProjects.add(projectName);
+            }
+        }
         return;
     }
     const matchedProjectNames = (0, exports.getMatchingStringsWithCache)(pattern.value, projectNames);

package/src/utils/handle-errors.js

@@ -24,22 +24,18 @@ async function handleErrors(isVerbose, fn) {
                 'message' in projectGraphError.cause) {
                 title += ' ' + projectGraphError.cause.message + '.';
             }
-            if (isVerbose) {
-                title += ' See errors below.';
-            }
-            const bodyLines = isVerbose
-                ? formatErrorStackAndCause(projectGraphError)
-                : ['Pass --verbose to see the stacktraces.'];
             output_1.output.error({
                 title,
-                bodyLines: bodyLines,
+                bodyLines: isVerbose
+                    ? formatErrorStackAndCause(projectGraphError, isVerbose)
+                    : projectGraphError.getErrors().map((e) => e.message),
             });
         }
         else {
             const lines = (err.message ? err.message : err.toString()).split('\n');
             const bodyLines = lines.slice(1);
             if (isVerbose) {
-                bodyLines.push(...formatErrorStackAndCause(err));
+                bodyLines.push(...formatErrorStackAndCause(err, isVerbose));
             }
             else if (err.stack) {
                 bodyLines.push('Pass --verbose to see the stacktrace.');
@@ -56,13 +52,13 @@ async function handleErrors(isVerbose, fn) {
         return 1;
     }
 }
-function formatErrorStackAndCause(error) {
+function formatErrorStackAndCause(error, verbose) {
     return [
-        error.stack || error.message,
+        verbose ? error.stack || error.message : error.message,
         ...(error.cause && typeof error.cause === 'object'
             ? [
                 'Caused by:',
-                'stack' in error.cause
+                verbose && 'stack' in error.cause
                     ? error.cause.stack.toString()
                     : error.cause.toString(),
             ]

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

@@ -36,6 +36,7 @@ export interface PackageJson {
         require?: string;
         import?: string;
         development?: string;
+        default?: string;
     }>;
     dependencies?: Record<string, string>;
     devDependencies?: Record<string, string>;

package/src/utils/plugins/plugin-capabilities.js

@@ -5,7 +5,7 @@ const path_1 = require("path");
 const fileutils_1 = require("../fileutils");
 const installation_directory_1 = require("../installation-directory");
 const plugins_1 = require("../../project-graph/plugins");
-const loader_1 = require("../../project-graph/plugins/loader");
+const in_process_loader_1 = require("../../project-graph/plugins/in-process-loader");
 function tryGetCollection(packageJsonPath, collectionFile, propName) {
     if (!collectionFile) {
         return null;
@@ -61,7 +61,7 @@ async function tryGetModule(packageJson, workspaceRoot) {
             packageJson['nx-migrations'] ??
             packageJson['schematics'] ??
             packageJson['builders']) {
-            const [pluginPromise] = (0, loader_1.loadNxPlugin)(packageJson.name, workspaceRoot);
+            const [pluginPromise] = (0, in_process_loader_1.loadNxPlugin)(packageJson.name, workspaceRoot);
             return await pluginPromise;
         }
         else {