nx 19.2.0-canary.20240604-0594deb → 19.2.0-canary.20240605-5a06daa

package/src/daemon/tmp-dir.js

@@ -13,7 +13,7 @@ const cache_directory_1 = require("../utils/cache-directory");
 const crypto_1 = require("crypto");
 const tmp_1 = require("tmp");
 const workspace_root_1 = require("../utils/workspace-root");
-exports.DAEMON_DIR_FOR_CURRENT_WORKSPACE = (0, path_1.join)(cache_directory_1.projectGraphCacheDirectory, 'd');
+exports.DAEMON_DIR_FOR_CURRENT_WORKSPACE = (0, path_1.join)(cache_directory_1.workspaceDataDirectory, 'd');
 exports.DAEMON_OUTPUT_LOG_FILE = (0, path_1.join)(exports.DAEMON_DIR_FOR_CURRENT_WORKSPACE, 'daemon.log');
 const getDaemonSocketDir = () => (0, path_1.join)(getSocketDir(), 
 // As per notes above on socket/named pipe length limitations, we keep this intentionally short

package/src/devkit-exports.d.ts

@@ -13,7 +13,7 @@ export type { WorkspaceJsonConfiguration, ProjectsConfigurations, TargetDependen
 /**
  * @category Workspace
  */
-export type { Generator, GeneratorCallback, Executor, ExecutorContext, TaskGraphExecutor, GeneratorsJson, ExecutorsJson, MigrationsJson, CustomHasher, HasherContext, } from './config/misc-interfaces';
+export type { Generator, GeneratorCallback, PromiseExecutor, AsyncIteratorExecutor, Executor, ExecutorContext, TaskGraphExecutor, GeneratorsJson, ExecutorsJson, MigrationsJson, CustomHasher, HasherContext, } from './config/misc-interfaces';
 export { workspaceLayout } from './config/configuration';
 export type { NxPlugin, NxPluginV2, CreateNodes, CreateNodesFunction, CreateNodesResult, CreateNodesContext, CreateNodesContextV2, CreateNodesFunctionV2, CreateNodesResultV2, CreateNodesV2, CreateDependencies, CreateDependenciesContext, CreateMetadata, CreateMetadataContext, ProjectsMetadata, } from './project-graph/plugins';
 export { AggregateCreateNodesError } from './project-graph/error-types';

package/src/migrations/update-19-2-0/move-workspace-data-directory.d.ts

@@ -0,0 +1,4 @@
+import { Tree } from '../../generators/tree';
+export default function moveGraphCacheDirectory(tree: Tree): Promise<void>;
+export declare function updatePrettierIgnore(tree: Tree): void;
+export declare function updateGitIgnore(tree: Tree): void;

package/src/migrations/update-19-2-0/move-workspace-data-directory.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.updateGitIgnore = exports.updatePrettierIgnore = void 0;
+async function moveGraphCacheDirectory(tree) {
+    updateGitIgnore(tree);
+    updatePrettierIgnore(tree);
+}
+exports.default = moveGraphCacheDirectory;
+function updatePrettierIgnore(tree) {
+    if (tree.exists('.prettierignore')) {
+        const ignored = tree.read('.prettierignore', 'utf-8');
+        if (!ignored?.includes('.nx/workspace-data')) {
+            tree.write('.prettierignore', [ignored, '/.nx/workspace-data'].join('\n'));
+        }
+    }
+}
+exports.updatePrettierIgnore = updatePrettierIgnore;
+function updateGitIgnore(tree) {
+    const gitignore = tree.read('.gitignore', 'utf-8');
+    if (!gitignore) {
+        return;
+    }
+    const includesNxWorkspaceData = gitignore.includes('.nx/workspace-data');
+    if (includesNxWorkspaceData) {
+        return;
+    }
+    const includesNxCache = gitignore.includes('.nx/cache');
+    if (!includesNxCache) {
+        return;
+    }
+    const updatedGitignore = gitignore.replace('.nx/cache', ['.nx/cache', '.nx/workspace-data'].join('\n'));
+    tree.write('.gitignore', updatedGitignore);
+}
+exports.updateGitIgnore = updateGitIgnore;

package/src/plugins/js/index.js

@@ -101,5 +101,5 @@ function writeLastProcessedLockfileHash(hash, lockFile) {
 function readCachedParsedLockFile() {
     return JSON.parse((0, fs_1.readFileSync)(cachedParsedLockFile).toString());
 }
-const lockFileHashFile = (0, path_1.join)(cache_directory_1.projectGraphCacheDirectory, 'lockfile.hash');
-const cachedParsedLockFile = (0, path_1.join)(cache_directory_1.projectGraphCacheDirectory, 'parsed-lock-file.json');
+const lockFileHashFile = (0, path_1.join)(cache_directory_1.workspaceDataDirectory, 'lockfile.hash');
+const cachedParsedLockFile = (0, path_1.join)(cache_directory_1.workspaceDataDirectory, 'parsed-lock-file.json');

package/src/plugins/js/project-graph/affected/lock-file-changes.js

@@ -1,7 +1,18 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getTouchedProjectsFromLockFile = void 0;
+const configuration_1 = require("../../../../config/configuration");
+const config_1 = require("../../utils/config");
+const find_matching_projects_1 = require("../../../../utils/find-matching-projects");
 const getTouchedProjectsFromLockFile = (fileChanges, projectGraphNodes) => {
+    const nxJson = (0, configuration_1.readNxJson)();
+    const { projectsAffectedByDependencyUpdates } = (0, config_1.jsPluginConfig)(nxJson);
+    if (projectsAffectedByDependencyUpdates === 'auto') {
+        return [];
+    }
+    else if (Array.isArray(projectsAffectedByDependencyUpdates)) {
+        return (0, find_matching_projects_1.findMatchingProjects)(projectsAffectedByDependencyUpdates, projectGraphNodes);
+    }
     const lockFiles = [
         'package-lock.json',
         'yarn.lock',

package/src/plugins/js/project-graph/affected/npm-packages.js

@@ -4,10 +4,12 @@ exports.getTouchedNpmPackages = void 0;
 const file_utils_1 = require("../../../../project-graph/file-utils");
 const json_diff_1 = require("../../../../utils/json-diff");
 const logger_1 = require("../../../../utils/logger");
+const get_package_name_from_import_path_1 = require("../../../../utils/get-package-name-from-import-path");
 const getTouchedNpmPackages = (touchedFiles, _, nxJson, packageJson, projectGraph) => {
     const packageJsonChange = touchedFiles.find((f) => f.file === 'package.json');
     if (!packageJsonChange)
         return [];
+    const globalPackages = new Set(getGlobalPackages(nxJson.plugins));
     let touched = [];
     const changes = packageJsonChange.getChanges();
     const npmPackages = Object.values(projectGraph.externalNodes);
@@ -40,6 +42,11 @@ const getTouchedNpmPackages = (touchedFiles, _, nxJson, packageJson, projectGrap
                         touched.push(implementationNpmPackage.name);
                     }
                 }
+                if ('packageName' in npmPackage.data) {
+                    if (globalPackages.has(npmPackage.data.packageName)) {
+                        return Object.keys(projectGraph.nodes);
+                    }
+                }
             }
         }
         else if ((0, file_utils_1.isWholeFileChange)(c)) {
@@ -54,3 +61,8 @@ const getTouchedNpmPackages = (touchedFiles, _, nxJson, packageJson, projectGrap
     return touched;
 };
 exports.getTouchedNpmPackages = getTouchedNpmPackages;
+function getGlobalPackages(plugins) {
+    return (plugins ?? [])
+        .map((p) => (0, get_package_name_from_import_path_1.getPackageNameFromImportPath)(typeof p === 'string' ? p : p.plugin))
+        .concat('nx');
+}

package/src/plugins/js/project-graph/build-dependencies/target-project-locator.js

@@ -8,6 +8,7 @@ const fileutils_1 = require("../../../../utils/fileutils");
 const workspace_root_1 = require("../../../../utils/workspace-root");
 const resolve_relative_to_dir_1 = require("../../utils/resolve-relative-to-dir");
 const typescript_1 = require("../../utils/typescript");
+const get_package_name_from_import_path_1 = require("../../../../utils/get-package-name-from-import-path");
 /**
  * Use a shared cache to avoid repeated npm package resolution work within the TargetProjectLocator.
  */
@@ -17,7 +18,7 @@ const builtInModuleSet = new Set([
     ...node_module_1.builtinModules.map((x) => `node:${x}`),
 ]);
 function isBuiltinModuleImport(importExpr) {
-    const packageName = parsePackageNameFromImportExpression(importExpr);
+    const packageName = (0, get_package_name_from_import_path_1.getPackageNameFromImportPath)(importExpr);
     return builtInModuleSet.has(packageName);
 }
 exports.isBuiltinModuleImport = isBuiltinModuleImport;
@@ -111,7 +112,7 @@ class TargetProjectLocator {
      * @param projectRoot
      */
     findNpmProjectFromImport(importExpr, fromFilePath) {
-        const packageName = parsePackageNameFromImportExpression(importExpr);
+        const packageName = (0, get_package_name_from_import_path_1.getPackageNameFromImportPath)(importExpr);
         let fullFilePath = fromFilePath;
         let workspaceRelativeFilePath = fromFilePath;
         if (fromFilePath.startsWith(workspace_root_1.workspaceRoot)) {
@@ -271,12 +272,3 @@ class TargetProjectLocator {
     }
 }
 exports.TargetProjectLocator = TargetProjectLocator;
-function parsePackageNameFromImportExpression(importExpression) {
-    // Check if the package is scoped
-    if (importExpression.startsWith('@')) {
-        // For scoped packages, the package name is up to the second '/'
-        return importExpression.split('/').slice(0, 2).join('/');
-    }
-    // For unscoped packages, the package name is up to the first '/'
-    return importExpression.split('/')[0];
-}

package/src/plugins/js/utils/config.js

@@ -19,6 +19,7 @@ function jsPluginConfig(nxJson) {
             analyzePackageJson: true,
             analyzeSourceFiles: true,
             analyzeLockfile,
+            projectsAffectedByDependencyUpdates: 'all',
             ...nxJsonConfig,
         };
     }
@@ -27,6 +28,7 @@ function jsPluginConfig(nxJson) {
             analyzeLockfile: false,
             analyzePackageJson: false,
             analyzeSourceFiles: false,
+            projectsAffectedByDependencyUpdates: 'all',
         };
     }
     const packageJson = (0, fileutils_1.readJsonFile)((0, node_path_1.join)(workspace_root_1.workspaceRoot, 'package.json'));
@@ -52,6 +54,7 @@ function jsPluginConfig(nxJson) {
             analyzePackageJson: true,
             analyzeLockfile,
             analyzeSourceFiles: true,
+            projectsAffectedByDependencyUpdates: 'all',
         };
     }
     else {
@@ -59,6 +62,7 @@ function jsPluginConfig(nxJson) {
             analyzePackageJson: true,
             analyzeLockfile,
             analyzeSourceFiles: false,
+            projectsAffectedByDependencyUpdates: 'all',
         };
     }
 }

package/src/plugins/js/utils/register.d.ts

@@ -1,3 +1,4 @@
+import type { TsConfigOptions } from 'ts-node';
 import type { CompilerOptions } from 'typescript';
 /**
  * Optionally, if swc-node and tsconfig-paths are available in the current workspace, apply the require
@@ -23,8 +24,8 @@ export declare function registerTsProject(tsConfigPath: string): () => void;
  */
 export declare function registerTsProject(path: string, configFilename: string): any;
 export declare function getSwcTranspiler(compilerOptions: CompilerOptions): (...args: unknown[]) => unknown;
-export declare function getTsNodeTranspiler(compilerOptions: CompilerOptions): (...args: unknown[]) => unknown;
-export declare function getTranspiler(compilerOptions: CompilerOptions): () => (...args: unknown[]) => unknown;
+export declare function getTsNodeTranspiler(compilerOptions: CompilerOptions, tsNodeOptions?: TsConfigOptions): (...args: unknown[]) => unknown;
+export declare function getTranspiler(compilerOptions: CompilerOptions, tsConfigRaw?: unknown): () => (...args: unknown[]) => unknown;
 /**
  * Register ts-node or swc-node given a set of compiler options.
  *
@@ -33,7 +34,7 @@ export declare function getTranspiler(compilerOptions: CompilerOptions): () => (
  *
  * @returns cleanup method
  */
-export declare function registerTranspiler(compilerOptions: CompilerOptions): () => void;
+export declare function registerTranspiler(compilerOptions: CompilerOptions, tsConfigRaw?: unknown): () => void;
 /**
  * @param tsConfigPath Adds the paths from a tsconfig file into node resolutions
  * @returns cleanup function

package/src/plugins/js/utils/register.js

@@ -41,7 +41,7 @@ function getSwcTranspiler(compilerOptions) {
     return typeof cleanupFn === 'function' ? cleanupFn : () => { };
 }
 exports.getSwcTranspiler = getSwcTranspiler;
-function getTsNodeTranspiler(compilerOptions) {
+function getTsNodeTranspiler(compilerOptions, tsNodeOptions) {
     const { register } = require('ts-node');
     // ts-node doesn't provide a cleanup method
     const service = register({
@@ -60,7 +60,49 @@ function getTsNodeTranspiler(compilerOptions) {
     };
 }
 exports.getTsNodeTranspiler = getTsNodeTranspiler;
-function getTranspiler(compilerOptions) {
+/**
+ * Given the raw "ts-node" sub-object from a tsconfig, return an object with only the properties
+ * recognized by "ts-node"
+ *
+ * Adapted from the function of the same name in ts-node
+ */
+function filterRecognizedTsConfigTsNodeOptions(jsonObject) {
+    if (typeof jsonObject !== 'object' || jsonObject === null) {
+        return { recognized: {}, unrecognized: {} };
+    }
+    const { compiler, compilerHost, compilerOptions, emit, files, ignore, ignoreDiagnostics, logError, preferTsExts, pretty, require, skipIgnore, transpileOnly, typeCheck, transpiler, scope, scopeDir, moduleTypes, experimentalReplAwait, swc, experimentalResolver, esm, experimentalSpecifierResolution, experimentalTsImportSpecifiers, ...unrecognized } = jsonObject;
+    const filteredTsConfigOptions = {
+        compiler,
+        compilerHost,
+        compilerOptions,
+        emit,
+        experimentalReplAwait,
+        files,
+        ignore,
+        ignoreDiagnostics,
+        logError,
+        preferTsExts,
+        pretty,
+        require,
+        skipIgnore,
+        transpileOnly,
+        typeCheck,
+        transpiler,
+        scope,
+        scopeDir,
+        moduleTypes,
+        swc,
+        experimentalResolver,
+        esm,
+        experimentalSpecifierResolution,
+        experimentalTsImportSpecifiers,
+    };
+    // Use the typechecker to make sure this implementation has the correct set of properties
+    const catchExtraneousProps = null;
+    const catchMissingProps = null;
+    return { recognized: filteredTsConfigOptions, unrecognized };
+}
+function getTranspiler(compilerOptions, tsConfigRaw) {
     const preferTsNode = process.env.NX_PREFER_TS_NODE === 'true';
     if (!ts) {
         ts = require('typescript');
@@ -78,7 +120,8 @@ function getTranspiler(compilerOptions) {
     }
     // We can fall back on ts-node if it's available
     if (tsNodeInstalled) {
-        return () => getTsNodeTranspiler(compilerOptions);
+        const tsNodeOptions = filterRecognizedTsConfigTsNodeOptions(tsConfigRaw).recognized;
+        return () => getTsNodeTranspiler(compilerOptions, tsNodeOptions);
     }
 }
 exports.getTranspiler = getTranspiler;
@@ -90,7 +133,7 @@ exports.getTranspiler = getTranspiler;
  *
  * @returns cleanup method
  */
-function registerTranspiler(compilerOptions) {
+function registerTranspiler(compilerOptions, tsConfigRaw) {
     // Function to register transpiler that returns cleanup function
     const transpiler = getTranspiler(compilerOptions);
     if (!transpiler) {

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

@@ -36,22 +36,22 @@ function filterAffectedProjects(graph, ctx) {
     };
     const reversed = (0, operators_1.reverse)(graph);
     ctx.touchedProjects.forEach((p) => {
-        addAffectedNodes(p, reversed, result, []);
+        addAffectedNodes(p, reversed, result, new Set());
     });
     ctx.touchedProjects.forEach((p) => {
-        addAffectedDependencies(p, reversed, result, []);
+        addAffectedDependencies(p, reversed, result, new Set());
     });
     return result;
 }
 function addAffectedNodes(startingProject, reversed, result, visited) {
-    if (visited.indexOf(startingProject) > -1)
+    if (visited.has(startingProject))
         return;
     const reversedNode = reversed.nodes[startingProject];
     const reversedExternalNode = reversed.externalNodes[startingProject];
     if (!reversedNode && !reversedExternalNode) {
         throw new Error(`Invalid project name is detected: "${startingProject}"`);
     }
-    visited.push(startingProject);
+    visited.add(startingProject);
     if (reversedNode) {
         result.nodes[startingProject] = reversedNode;
         result.dependencies[startingProject] = [];
@@ -62,9 +62,9 @@ function addAffectedNodes(startingProject, reversed, result, visited) {
     reversed.dependencies[startingProject]?.forEach(({ target }) => addAffectedNodes(target, reversed, result, visited));
 }
 function addAffectedDependencies(startingProject, reversed, result, visited) {
-    if (visited.indexOf(startingProject) > -1)
+    if (visited.has(startingProject))
         return;
-    visited.push(startingProject);
+    visited.add(startingProject);
     if (reversed.dependencies[startingProject]) {
         reversed.dependencies[startingProject].forEach(({ target }) => addAffectedDependencies(target, reversed, result, visited));
         reversed.dependencies[startingProject].forEach(({ type, source, target }) => {

package/src/project-graph/nx-deps-cache.js

@@ -8,12 +8,12 @@ const perf_hooks_1 = require("perf_hooks");
 const cache_directory_1 = require("../utils/cache-directory");
 const fileutils_1 = require("../utils/fileutils");
 const versions_1 = require("../utils/versions");
-exports.nxProjectGraph = (0, path_1.join)(cache_directory_1.projectGraphCacheDirectory, 'project-graph.json');
-exports.nxFileMap = (0, path_1.join)(cache_directory_1.projectGraphCacheDirectory, 'file-map.json');
+exports.nxProjectGraph = (0, path_1.join)(cache_directory_1.workspaceDataDirectory, 'project-graph.json');
+exports.nxFileMap = (0, path_1.join)(cache_directory_1.workspaceDataDirectory, 'file-map.json');
 function ensureCacheDirectory() {
     try {
-        if (!(0, fs_1.existsSync)(cache_directory_1.projectGraphCacheDirectory)) {
-            (0, fs_extra_1.ensureDirSync)(cache_directory_1.projectGraphCacheDirectory);
+        if (!(0, fs_1.existsSync)(cache_directory_1.workspaceDataDirectory)) {
+            (0, fs_extra_1.ensureDirSync)(cache_directory_1.workspaceDataDirectory);
         }
     }
     catch (e) {
@@ -27,8 +27,8 @@ function ensureCacheDirectory() {
          * In this case, we're creating the directory. If the operation failed, we ensure that the directory
          * exists before continuing (or raise an exception).
          */
-        if (!(0, fileutils_1.directoryExists)(cache_directory_1.projectGraphCacheDirectory)) {
-            throw new Error(`Failed to create directory: ${cache_directory_1.projectGraphCacheDirectory}`);
+        if (!(0, fileutils_1.directoryExists)(cache_directory_1.workspaceDataDirectory)) {
+            throw new Error(`Failed to create directory: ${cache_directory_1.workspaceDataDirectory}`);
         }
     }
 }

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

@@ -72,7 +72,7 @@ function registerPluginTSTranspiler() {
             experimentalDecorators: true,
             emitDecoratorMetadata: true,
             ...tsConfig.options,
-        }),
+        }, tsConfig.raw),
     ];
     exports.unregisterPluginTSTranspiler = () => {
         cleanupFns.forEach((fn) => fn?.());

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

@@ -9,12 +9,12 @@ import { LoadedNxPlugin } from '../plugins/internal-api';
  * @param nxJson
  */
 export declare function retrieveWorkspaceFiles(workspaceRoot: string, projectRootMap: Record<string, string>): Promise<{
-    allWorkspaceFiles: import("nx/src/devkit-exports").FileData[];
+    allWorkspaceFiles: import("../file-utils").FileData[];
     fileMap: {
         projectFileMap: ProjectFiles;
-        nonProjectFiles: import("nx/src/native").FileData[];
+        nonProjectFiles: import("../../native").FileData[];
     };
-    rustReferences: import("nx/src/native").NxWorkspaceFilesExternals;
+    rustReferences: import("../../native").NxWorkspaceFilesExternals;
 }>;
 /**
  * Walk through the workspace and return `ProjectConfigurations`. Only use this if the projectFileMap is not needed.

package/src/tasks-runner/task-env.js

@@ -81,14 +81,20 @@ function loadDotEnvFilesForTask(task, environmentVariables) {
         // Load DotEnv Files for a configuration in the project root
         ...(task.target.configuration
             ? [
+                `${task.projectRoot}/.env.${task.target.target}.${task.target.configuration}.local`,
                 `${task.projectRoot}/.env.${task.target.target}.${task.target.configuration}`,
+                `${task.projectRoot}/.env.${task.target.configuration}.local`,
                 `${task.projectRoot}/.env.${task.target.configuration}`,
+                `${task.projectRoot}/.${task.target.target}.${task.target.configuration}.local.env`,
                 `${task.projectRoot}/.${task.target.target}.${task.target.configuration}.env`,
+                `${task.projectRoot}/.${task.target.configuration}.local.env`,
                 `${task.projectRoot}/.${task.target.configuration}.env`,
             ]
             : []),
         // Load DotEnv Files for a target in the project root
+        `${task.projectRoot}/.env.${task.target.target}.local`,
         `${task.projectRoot}/.env.${task.target.target}`,
+        `${task.projectRoot}/.${task.target.target}.local.env`,
         `${task.projectRoot}/.${task.target.target}.env`,
         `${task.projectRoot}/.env.local`,
         `${task.projectRoot}/.local.env`,
@@ -96,14 +102,20 @@ function loadDotEnvFilesForTask(task, environmentVariables) {
         // Load DotEnv Files for a configuration in the workspace root
         ...(task.target.configuration
             ? [
+                `.env.${task.target.target}.${task.target.configuration}.local`,
                 `.env.${task.target.target}.${task.target.configuration}`,
+                `.env.${task.target.configuration}.local`,
                 `.env.${task.target.configuration}`,
+                `.${task.target.target}.${task.target.configuration}.local.env`,
                 `.${task.target.target}.${task.target.configuration}.env`,
+                `.${task.target.configuration}.local.env`,
                 `.${task.target.configuration}.env`,
             ]
             : []),
         // Load DotEnv Files for a target in the workspace root
+        `.env.${task.target.target}.local`,
         `.env.${task.target.target}`,
+        `.${task.target.target}.local.env`,
         `.${task.target.target}.env`,
         // Load base DotEnv Files at workspace root
         `.local.env`,

package/src/utils/cache-directory.d.ts

@@ -3,4 +3,4 @@
  */
 export declare const cacheDir: string;
 export declare function cacheDirectoryForWorkspace(workspaceRoot: string): string;
-export declare const projectGraphCacheDirectory: string;
+export declare const workspaceDataDirectory: string;

package/src/utils/cache-directory.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.projectGraphCacheDirectory = exports.cacheDirectoryForWorkspace = exports.cacheDir = void 0;
+exports.workspaceDataDirectory = exports.cacheDirectoryForWorkspace = exports.cacheDir = void 0;
 const fs_1 = require("fs");
 const path_1 = require("path");
 const fileutils_1 = require("./fileutils");
@@ -35,7 +35,7 @@ function cacheDirectory(root, cacheDirectory) {
         return defaultCacheDirectory(root);
     }
 }
-function defaultCacheDirectory(root) {
+function pickCacheDirectory(root, nonNxCacheDirectory, nxCacheDirectory) {
     // If nx.json doesn't exist the repo can't utilize
     // caching, so .nx/cache is less relevant. Lerna users
     // that don't want to fully opt in to Nx at this time
@@ -44,9 +44,15 @@ function defaultCacheDirectory(root) {
     // this for the time being.
     if ((0, fs_1.existsSync)((0, path_1.join)(root, 'lerna.json')) &&
         !(0, fs_1.existsSync)((0, path_1.join)(root, 'nx.json'))) {
-        return (0, path_1.join)(root, 'node_modules', '.cache', 'nx');
+        return (0, path_1.join)(root, 'node_modules', '.cache', nonNxCacheDirectory);
     }
-    return (0, path_1.join)(root, '.nx', 'cache');
+    return (0, path_1.join)(root, '.nx', nxCacheDirectory);
+}
+function defaultCacheDirectory(root) {
+    return pickCacheDirectory(root, 'nx', 'cache');
+}
+function defaultWorkspaceDataDirectory(root) {
+    return pickCacheDirectory(root, 'nx-workspace-data', 'workspace-data');
 }
 /**
  * Path to the directory where Nx stores its cache and daemon-related files.
@@ -56,5 +62,6 @@ function cacheDirectoryForWorkspace(workspaceRoot) {
     return cacheDirectory(workspaceRoot, readCacheDirectoryProperty(workspaceRoot));
 }
 exports.cacheDirectoryForWorkspace = cacheDirectoryForWorkspace;
-exports.projectGraphCacheDirectory = absolutePath(workspace_root_1.workspaceRoot, process.env.NX_PROJECT_GRAPH_CACHE_DIRECTORY ??
-    defaultCacheDirectory(workspace_root_1.workspaceRoot));
+exports.workspaceDataDirectory = absolutePath(workspace_root_1.workspaceRoot, process.env.NX_WORKSPACE_DATA_DIRECTORY ??
+    process.env.NX_PROJECT_GRAPH_CACHE_DIRECTORY ??
+    defaultWorkspaceDataDirectory(workspace_root_1.workspaceRoot));

package/src/utils/get-package-name-from-import-path.d.ts

@@ -0,0 +1 @@
+export declare function getPackageNameFromImportPath(importExpression: string): string;

package/src/utils/get-package-name-from-import-path.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getPackageNameFromImportPath = void 0;
+//# Converts import paths to package names.
+//# e.g. - `@nx/workspace`        -> `@nx/workspace`
+//#      - `@nx/workspace/plugin` -> `@nx/workspace`
+//#      - `@nx/workspace/other`  -> `@nx/workspace`
+//#      - `nx/plugin`            -> `nx`
+function getPackageNameFromImportPath(importExpression) {
+    // Check if the package is scoped
+    if (importExpression.startsWith('@')) {
+        // For scoped packages, the package name is up to the second '/'
+        return importExpression.split('/').slice(0, 2).join('/');
+    }
+    // For unscoped packages, the package name is up to the first '/'
+    return importExpression.split('/')[0];
+}
+exports.getPackageNameFromImportPath = getPackageNameFromImportPath;

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

@@ -61,6 +61,7 @@ export interface PackageJson {
     executors?: string;
     'nx-migrations'?: string | NxMigrationsConfiguration;
     'ng-update'?: string | NxMigrationsConfiguration;
+    packageManager?: string;
 }
 export declare function normalizePackageGroup(packageGroup: PackageGroup): ArrayPackageGroup;
 export declare function readNxMigrateConfig(json: Partial<PackageJson>): NxMigrationsConfiguration & {

package/src/utils/package-manager.js

@@ -60,8 +60,15 @@ exports.isWorkspacesEnabled = isWorkspacesEnabled;
 function getPackageManagerCommand(packageManager = detectPackageManager(), root = workspace_root_1.workspaceRoot) {
     const commands = {
         yarn: () => {
-            const yarnVersion = getPackageManagerVersion('yarn', root);
-            const useBerry = (0, semver_1.gte)(yarnVersion, '2.0.0');
+            let yarnVersion, useBerry;
+            try {
+                yarnVersion = getPackageManagerVersion('yarn', root);
+                useBerry = (0, semver_1.gte)(yarnVersion, '2.0.0');
+            }
+            catch {
+                yarnVersion = 'latest';
+                useBerry = true;
+            }
             return {
                 preInstall: `yarn set version ${yarnVersion}`,
                 install: 'yarn',
@@ -84,9 +91,16 @@ function getPackageManagerCommand(packageManager = detectPackageManager(), root
             };
         },
         pnpm: () => {
-            const pnpmVersion = getPackageManagerVersion('pnpm', root);
-            const modernPnpm = (0, semver_1.gte)(pnpmVersion, '6.13.0');
-            const includeDoubleDashBeforeArgs = (0, semver_1.lt)(pnpmVersion, '7.0.0');
+            let modernPnpm, includeDoubleDashBeforeArgs;
+            try {
+                const pnpmVersion = getPackageManagerVersion('pnpm', root);
+                modernPnpm = (0, semver_1.gte)(pnpmVersion, '6.13.0');
+                includeDoubleDashBeforeArgs = (0, semver_1.lt)(pnpmVersion, '7.0.0');
+            }
+            catch {
+                modernPnpm = true;
+                includeDoubleDashBeforeArgs = true;
+            }
             const isPnpmWorkspace = (0, fs_1.existsSync)((0, path_1.join)(root, 'pnpm-workspace.yaml'));
             return {
                 install: 'pnpm install --no-frozen-lockfile', // explicitly disable in case of CI
@@ -148,10 +162,29 @@ exports.getPackageManagerCommand = getPackageManagerCommand;
  * but it can also be passed in explicitly.
  */
 function getPackageManagerVersion(packageManager = detectPackageManager(), cwd = process.cwd()) {
-    return (0, child_process_1.execSync)(`${packageManager} --version`, {
-        cwd,
-        encoding: 'utf-8',
-    }).trim();
+    let version;
+    try {
+        version = (0, child_process_1.execSync)(`${packageManager} --version`, {
+            cwd,
+            encoding: 'utf-8',
+        }).trim();
+    }
+    catch {
+        if ((0, fs_1.existsSync)((0, path_1.join)(cwd, 'package.json'))) {
+            const packageVersion = (0, fileutils_1.readJsonFile)((0, path_1.join)(cwd, 'package.json'))?.packageManager;
+            if (packageVersion) {
+                const [packageManagerFromPackageJson, versionFromPackageJson] = packageVersion.split('@');
+                if (packageManagerFromPackageJson === packageManager &&
+                    versionFromPackageJson) {
+                    version = versionFromPackageJson;
+                }
+            }
+        }
+    }
+    if (!version) {
+        throw new Error(`Cannot determine the version of ${packageManager}.`);
+    }
+    return version;
 }
 exports.getPackageManagerVersion = getPackageManagerVersion;
 /**

package/src/utils/params.d.ts

@@ -79,7 +79,7 @@ export type Options = {
     '--'?: Unmatched[];
     [k: string]: string | number | boolean | string[] | Unmatched[] | undefined;
 };
-export declare function handleErrors(isVerbose: boolean, fn: Function): Promise<any>;
+export declare function handleErrors(isVerbose: boolean, fn: Function): Promise<number>;
 export declare function convertToCamelCase(parsed: {
     [k: string]: any;
 }, schema: Schema): Options;

package/src/utils/params.js

@@ -6,7 +6,11 @@ const output_1 = require("./output");
 const client_1 = require("../daemon/client/client");
 async function handleErrors(isVerbose, fn) {
     try {
-        return await fn();
+        const result = await fn();
+        if (typeof result === 'number') {
+            return result;
+        }
+        return 0;
     }
     catch (err) {
         err ||= new Error('Unknown error caught');