nx 20.4.0 → 20.4.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nx",
-  "version": "20.4.0",
+  "version": "20.4.1",
   "private": false,
   "description": "The core Nx plugin contains the core functionality of Nx like the project graph, nx commands and task orchestration.",
   "repository": {
@@ -82,16 +82,16 @@
     }
   },
   "optionalDependencies": {
-    "@nx/nx-darwin-arm64": "20.4.0",
-    "@nx/nx-darwin-x64": "20.4.0",
-    "@nx/nx-freebsd-x64": "20.4.0",
-    "@nx/nx-linux-arm-gnueabihf": "20.4.0",
-    "@nx/nx-linux-arm64-gnu": "20.4.0",
-    "@nx/nx-linux-arm64-musl": "20.4.0",
-    "@nx/nx-linux-x64-gnu": "20.4.0",
-    "@nx/nx-linux-x64-musl": "20.4.0",
-    "@nx/nx-win32-arm64-msvc": "20.4.0",
-    "@nx/nx-win32-x64-msvc": "20.4.0"
+    "@nx/nx-darwin-arm64": "20.4.1",
+    "@nx/nx-darwin-x64": "20.4.1",
+    "@nx/nx-freebsd-x64": "20.4.1",
+    "@nx/nx-linux-arm-gnueabihf": "20.4.1",
+    "@nx/nx-linux-arm64-gnu": "20.4.1",
+    "@nx/nx-linux-arm64-musl": "20.4.1",
+    "@nx/nx-linux-x64-gnu": "20.4.1",
+    "@nx/nx-linux-x64-musl": "20.4.1",
+    "@nx/nx-win32-arm64-msvc": "20.4.1",
+    "@nx/nx-win32-x64-msvc": "20.4.1"
   },
   "nx-migrations": {
     "migrations": "./migrations.json",

package/plugins/package-json.js

@@ -25,7 +25,8 @@ const plugin = {
         '*/**/package.json',
         (configFiles, options, context) => {
             const cache = readPackageJsonConfigurationCache();
-            const result = (0, plugins_1.createNodesFromFiles)((f) => (0, package_json_1.createNodeFromPackageJson)(f, workspace_root_1.workspaceRoot, cache), configFiles, options, context);
+            const isInPackageJsonWorkspaces = (0, package_json_1.buildPackageJsonWorkspacesMatcher)(context.workspaceRoot, (f) => (0, fileutils_1.readJsonFile)((0, path_1.join)(context.workspaceRoot, f)));
+            const result = (0, plugins_1.createNodesFromFiles)((packageJsonPath) => (0, package_json_1.createNodeFromPackageJson)(packageJsonPath, workspace_root_1.workspaceRoot, cache, isInPackageJsonWorkspaces(packageJsonPath)), configFiles, options, context);
             writeCache(cache);
             return result;
         },

package/schemas/nx-schema.json

@@ -569,6 +569,13 @@
         "cache": {
           "type": "boolean",
           "description": "Specifies if the given target should be cacheable"
+        },
+        "syncGenerators": {
+          "type": "array",
+          "items": {
+            "type": "string"
+          },
+          "description": "List of generators to run before the target to ensure the workspace is up to date"
         }
       },
       "additionalProperties": false

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

@@ -118,10 +118,10 @@ class Migrator {
         const packagesToCheck = await this.populatePackageJsonUpdatesAndGetPackagesToCheck(targetPackage, target);
         for (const packageToCheck of packagesToCheck) {
             const filteredUpdates = {};
-            for (const packageUpdate of packageToCheck.updates) {
+            for (const [packageUpdateKey, packageUpdate] of Object.entries(packageToCheck.updates)) {
                 if (this.areRequirementsMet(packageUpdate.requires) &&
                     (!this.interactive ||
-                        (await this.runPackageJsonUpdatesConfirmationPrompt(packageUpdate)))) {
+                        (await this.runPackageJsonUpdatesConfirmationPrompt(packageUpdate, packageUpdateKey, packageToCheck.package)))) {
                     Object.entries(packageUpdate.packages).forEach(([name, update]) => {
                         filteredUpdates[name] = update;
                         this.packageUpdates[name] = update;
@@ -166,15 +166,15 @@ class Migrator {
             addToPackageJson: target.addToPackageJson || false,
         });
         const { packageJsonUpdates, packageGroupOrder } = this.getPackageJsonUpdatesFromMigrationConfig(targetPackage, targetVersion, migrationConfig);
-        if (!packageJsonUpdates.length) {
+        if (!Object.keys(packageJsonUpdates).length) {
             return [];
         }
-        const shouldCheckUpdates = packageJsonUpdates.some((packageJsonUpdate) => (this.interactive && packageJsonUpdate['x-prompt']) ||
+        const shouldCheckUpdates = Object.values(packageJsonUpdates).some((packageJsonUpdate) => (this.interactive && packageJsonUpdate['x-prompt']) ||
             Object.keys(packageJsonUpdate.requires ?? {}).length);
         if (shouldCheckUpdates) {
             return [{ package: targetPackage, updates: packageJsonUpdates }];
         }
-        const packageUpdatesToApply = packageJsonUpdates.reduce((m, c) => ({ ...m, ...c.packages }), {});
+        const packageUpdatesToApply = Object.values(packageJsonUpdates).reduce((m, c) => ({ ...m, ...c.packages }), {});
         return (await Promise.all(Object.entries(packageUpdatesToApply).map(([packageName, packageUpdate]) => this.populatePackageJsonUpdatesAndGetPackagesToCheck(packageName, packageUpdate))))
             .filter((pkgs) => pkgs.length)
             .flat()
@@ -185,7 +185,7 @@ class Migrator {
         const packageGroupOrder = this.getPackageJsonUpdatesFromPackageGroup(packageName, targetVersion, migrationConfig);
         if (!migrationConfig.packageJsonUpdates ||
             !this.getPkgVersion(packageName)) {
-            return { packageJsonUpdates: [], packageGroupOrder };
+            return { packageJsonUpdates: {}, packageGroupOrder };
         }
         const packageJsonUpdates = this.filterPackageJsonUpdates(migrationConfig.packageJsonUpdates, packageName, targetVersion);
         return { packageJsonUpdates, packageGroupOrder };
@@ -228,8 +228,8 @@ class Migrator {
         return packageGroupOrder;
     }
     filterPackageJsonUpdates(packageJsonUpdates, packageName, targetVersion) {
-        const filteredPackageJsonUpdates = [];
-        for (const packageJsonUpdate of Object.values(packageJsonUpdates)) {
+        const filteredPackageJsonUpdates = {};
+        for (const [packageJsonUpdateKey, packageJsonUpdate] of Object.entries(packageJsonUpdates)) {
             if (!packageJsonUpdate.packages ||
                 this.lt(packageJsonUpdate.version, this.getPkgVersion(packageName)) ||
                 this.gt(packageJsonUpdate.version, targetVersion)) {
@@ -254,7 +254,7 @@ class Migrator {
             }
             if (Object.keys(filtered).length) {
                 packageJsonUpdate.packages = filtered;
-                filteredPackageJsonUpdates.push(packageJsonUpdate);
+                filteredPackageJsonUpdates[packageJsonUpdateKey] = packageJsonUpdate;
             }
         }
         return filteredPackageJsonUpdates;
@@ -313,7 +313,7 @@ class Migrator {
                 includePrerelease: true,
             }));
     }
-    async runPackageJsonUpdatesConfirmationPrompt(packageUpdate) {
+    async runPackageJsonUpdatesConfirmationPrompt(packageUpdate, packageUpdateKey, packageName) {
         if (!packageUpdate['x-prompt']) {
             return Promise.resolve(true);
         }
@@ -322,14 +322,17 @@ class Migrator {
             // a same prompt was already answered, skip
             return Promise.resolve(false);
         }
-        return await (0, enquirer_1.prompt)([
-            {
-                name: 'shouldApply',
-                type: 'confirm',
-                message: packageUpdate['x-prompt'],
-                initial: true,
-            },
-        ]).then(({ shouldApply }) => {
+        const promptConfig = {
+            name: 'shouldApply',
+            type: 'confirm',
+            message: packageUpdate['x-prompt'],
+            initial: true,
+        };
+        if (packageName.startsWith('@nx/')) {
+            // @ts-expect-error -- enquirer types aren't correct, footer does exist
+            promptConfig.footer = () => chalk.dim(`  View migration details at https://nx.dev/nx-api/${packageName.replace('@nx/', '')}#${packageUpdateKey.replace(/[-\.]/g, '')}packageupdates`);
+        }
+        return await (0, enquirer_1.prompt)([promptConfig]).then(({ shouldApply }) => {
             this.promptAnswers[promptKey] = shouldApply;
             if (!shouldApply &&
                 (!this.minVersionWithSkippedUpdates ||

package/src/config/schema-utils.js

@@ -79,11 +79,11 @@ function resolveSchema(schemaPath, directory, packageName, projects) {
         paths: [directory],
     });
 }
-let packageEntryPointsToProjectMap;
+let packageToProjectMap;
 function tryResolveFromSource(path, directory, packageName, projects) {
-    packageEntryPointsToProjectMap ??=
-        (0, packages_1.getPackageEntryPointsToProjectMap)(projects);
-    const localProject = packageEntryPointsToProjectMap[packageName];
+    packageToProjectMap ??=
+        (0, packages_1.getWorkspacePackagesMetadata)(projects).packageToProjectMap;
+    const localProject = packageToProjectMap[packageName];
     if (!localProject) {
         // it doesn't match any of the package names from the local projects
         return null;

package/src/config/workspace-json-project-json.d.ts

@@ -126,6 +126,8 @@ export interface ProjectMetadata {
     js?: {
         packageName: string;
         packageExports?: PackageJson['exports'];
+        packageMain?: string;
+        isInPackageManagerWorkspaces?: boolean;
     };
 }
 export interface TargetMetadata {

package/src/daemon/server/project-graph-incremental-recomputation.js

@@ -189,6 +189,7 @@ async function processFilesAndCreateAndSerializeProjectGraph(plugins) {
                 };
             }
         }
+        (0, nx_deps_cache_1.writeCache)(g.projectFileMapCache, g.projectGraph, projectConfigurationsResult.sourceMaps, errors);
         if (errors.length > 0) {
             return {
                 error: new error_types_1.DaemonProjectGraphError(errors, g.projectGraph, projectConfigurationsResult.sourceMaps),
@@ -202,7 +203,6 @@ async function processFilesAndCreateAndSerializeProjectGraph(plugins) {
             };
         }
         else {
-            (0, nx_deps_cache_1.writeCache)(g.projectFileMapCache, g.projectGraph);
             return g;
         }
     }

package/src/devkit-exports.d.ts

@@ -16,7 +16,7 @@ export type { WorkspaceJsonConfiguration, ProjectsConfigurations, TargetDependen
 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, PreTasksExecution, PreTasksExecutionContext, PostTasksExecution, PostTasksExecutionContext, } from './project-graph/plugins';
-export { AggregateCreateNodesError } from './project-graph/error-types';
+export { AggregateCreateNodesError, StaleProjectGraphCacheError, } from './project-graph/error-types';
 export { createNodesFromFiles } from './project-graph/plugins';
 /**
  * @category Tasks

package/src/devkit-exports.js

@@ -4,11 +4,12 @@
  * Try hard to not add to this API to reduce the surface area we need to maintain.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.isDaemonEnabled = exports.createProjectFileMapUsingProjectGraph = exports.cacheDir = exports.hashArray = exports.defaultTasksRunner = exports.getOutputsForTargetAndConfiguration = exports.readProjectsConfigurationFromProjectGraph = exports.readCachedProjectGraph = exports.createProjectGraphAsync = exports.reverse = exports.workspaceRoot = exports.normalizePath = exports.joinPathFragments = exports.stripIndents = exports.writeJsonFile = exports.readJsonFile = exports.stripJsonComments = exports.serializeJson = exports.parseJson = exports.updateJson = exports.writeJson = exports.readJson = exports.validateDependency = exports.DependencyType = exports.updateNxJson = exports.readNxJson = exports.globAsync = exports.glob = exports.getProjects = exports.updateProjectConfiguration = exports.removeProjectConfiguration = exports.readProjectConfiguration = exports.addProjectConfiguration = exports.runExecutor = exports.isWorkspacesEnabled = exports.getPackageManagerVersion = exports.detectPackageManager = exports.getPackageManagerCommand = exports.output = exports.logger = exports.createNodesFromFiles = exports.AggregateCreateNodesError = exports.workspaceLayout = void 0;
+exports.isDaemonEnabled = exports.createProjectFileMapUsingProjectGraph = exports.cacheDir = exports.hashArray = exports.defaultTasksRunner = exports.getOutputsForTargetAndConfiguration = exports.readProjectsConfigurationFromProjectGraph = exports.readCachedProjectGraph = exports.createProjectGraphAsync = exports.reverse = exports.workspaceRoot = exports.normalizePath = exports.joinPathFragments = exports.stripIndents = exports.writeJsonFile = exports.readJsonFile = exports.stripJsonComments = exports.serializeJson = exports.parseJson = exports.updateJson = exports.writeJson = exports.readJson = exports.validateDependency = exports.DependencyType = exports.updateNxJson = exports.readNxJson = exports.globAsync = exports.glob = exports.getProjects = exports.updateProjectConfiguration = exports.removeProjectConfiguration = exports.readProjectConfiguration = exports.addProjectConfiguration = exports.runExecutor = exports.isWorkspacesEnabled = exports.getPackageManagerVersion = exports.detectPackageManager = exports.getPackageManagerCommand = exports.output = exports.logger = exports.createNodesFromFiles = exports.StaleProjectGraphCacheError = exports.AggregateCreateNodesError = exports.workspaceLayout = void 0;
 var configuration_1 = require("./config/configuration");
 Object.defineProperty(exports, "workspaceLayout", { enumerable: true, get: function () { return configuration_1.workspaceLayout; } });
 var error_types_1 = require("./project-graph/error-types");
 Object.defineProperty(exports, "AggregateCreateNodesError", { enumerable: true, get: function () { return error_types_1.AggregateCreateNodesError; } });
+Object.defineProperty(exports, "StaleProjectGraphCacheError", { enumerable: true, get: function () { return error_types_1.StaleProjectGraphCacheError; } });
 var plugins_1 = require("./project-graph/plugins");
 Object.defineProperty(exports, "createNodesFromFiles", { enumerable: true, get: function () { return plugins_1.createNodesFromFiles; } });
 /**

package/src/executors/run-commands/run-commands.impl.d.ts

@@ -14,6 +14,7 @@ export interface RunCommandsOptions extends Json {
          */
         description?: string;
         prefix?: string;
+        prefixColor?: string;
         color?: string;
         bgColor?: string;
     } | string)[];

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

@@ -46,9 +46,9 @@ async function default_1(options, context) {
     if (normalized.readyWhenStatus.length && !normalized.parallel) {
         throw new Error('ERROR: Bad executor config for run-commands - "readyWhen" can only be used when "parallel=true".');
     }
-    if (options.commands.find((c) => c.prefix || c.color || c.bgColor) &&
+    if (options.commands.find((c) => c.prefix || c.prefixColor || c.color || c.bgColor) &&
         !options.parallel) {
-        throw new Error('ERROR: Bad executor config for run-commands - "prefix", "color" and "bgColor" can only be set when "parallel=true".');
+        throw new Error('ERROR: Bad executor config for run-commands - "prefix", "prefixColor", "color" and "bgColor" can only be set when "parallel=true".');
     }
     try {
         const result = options.parallel
@@ -263,7 +263,14 @@ function addColorAndPrefix(out, config) {
     if (config.prefix) {
         out = out
             .split('\n')
-            .map((l) => l.trim().length > 0 ? `${chalk.bold(config.prefix)} ${l}` : l)
+            .map((l) => {
+            let prefixText = config.prefix;
+            if (config.prefixColor && chalk[config.prefixColor]) {
+                prefixText = chalk[config.prefixColor](prefixText);
+            }
+            prefixText = chalk.bold(prefixText);
+            return l.trim().length > 0 ? `${prefixText} ${l}` : l;
+        })
             .join('\n');
     }
     if (config.color && chalk[config.color]) {

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

@@ -40,6 +40,20 @@
                 "type": "string",
                 "description": "Prefix in front of every line out of the output"
               },
+              "prefixColor": {
+                "type": "string",
+                "description": "Color of the prefix",
+                "enum": [
+                  "black",
+                  "red",
+                  "green",
+                  "yellow",
+                  "blue",
+                  "magenta",
+                  "cyan",
+                  "white"
+                ]
+              },
               "color": {
                 "type": "string",
                 "description": "Color of the output",

package/src/native/index.d.ts

@@ -13,6 +13,15 @@ export declare class ChildProcess {
   onOutput(callback: (message: string) => void): void
 }
 
+export declare class FileLock {
+  locked: boolean
+  constructor(lockFilePath: string)
+  unlock(): void
+  check(): boolean
+  wait(): Promise<void>
+  lock(): void
+}
+
 export declare class HashPlanner {
   constructor(nxJson: NxJson, projectGraph: ExternalObject<ProjectGraph>)
   getPlans(taskIds: Array<string>, taskGraph: TaskGraph): Record<string, string[]>

package/src/native/native-bindings.js

@@ -362,6 +362,7 @@ if (!nativeBinding) {
 }
 
 module.exports.ChildProcess = nativeBinding.ChildProcess
+module.exports.FileLock = nativeBinding.FileLock
 module.exports.HashPlanner = nativeBinding.HashPlanner
 module.exports.ImportResult = nativeBinding.ImportResult
 module.exports.NxCache = nativeBinding.NxCache

package/src/native/nx.wasi-browser.js

@@ -85,15 +85,18 @@ function __napi_rs_initialize_modules(__napiInstance) {
   __napiInstance.exports['__napi_register__ExternalDependenciesInput_struct_36']?.()
   __napiInstance.exports['__napi_register__DepsOutputsInput_struct_37']?.()
   __napiInstance.exports['__napi_register__NxJson_struct_38']?.()
-  __napiInstance.exports['__napi_register__WorkspaceContext_struct_39']?.()
-  __napiInstance.exports['__napi_register__WorkspaceContext_impl_48']?.()
-  __napiInstance.exports['__napi_register__WorkspaceErrors_49']?.()
-  __napiInstance.exports['__napi_register__NxWorkspaceFiles_struct_50']?.()
-  __napiInstance.exports['__napi_register__NxWorkspaceFilesExternals_struct_51']?.()
-  __napiInstance.exports['__napi_register__UpdatedWorkspaceFiles_struct_52']?.()
-  __napiInstance.exports['__napi_register__FileMap_struct_53']?.()
-  __napiInstance.exports['__napi_register____test_only_transfer_file_map_54']?.()
+  __napiInstance.exports['__napi_register__FileLock_struct_39']?.()
+  __napiInstance.exports['__napi_register__FileLock_impl_41']?.()
+  __napiInstance.exports['__napi_register__WorkspaceContext_struct_42']?.()
+  __napiInstance.exports['__napi_register__WorkspaceContext_impl_51']?.()
+  __napiInstance.exports['__napi_register__WorkspaceErrors_52']?.()
+  __napiInstance.exports['__napi_register__NxWorkspaceFiles_struct_53']?.()
+  __napiInstance.exports['__napi_register__NxWorkspaceFilesExternals_struct_54']?.()
+  __napiInstance.exports['__napi_register__UpdatedWorkspaceFiles_struct_55']?.()
+  __napiInstance.exports['__napi_register__FileMap_struct_56']?.()
+  __napiInstance.exports['__napi_register____test_only_transfer_file_map_57']?.()
 }
+export const FileLock = __napiModule.exports.FileLock
 export const HashPlanner = __napiModule.exports.HashPlanner
 export const ImportResult = __napiModule.exports.ImportResult
 export const TaskHasher = __napiModule.exports.TaskHasher

package/src/native/nx.wasi.cjs

@@ -116,15 +116,18 @@ function __napi_rs_initialize_modules(__napiInstance) {
   __napiInstance.exports['__napi_register__ExternalDependenciesInput_struct_36']?.()
   __napiInstance.exports['__napi_register__DepsOutputsInput_struct_37']?.()
   __napiInstance.exports['__napi_register__NxJson_struct_38']?.()
-  __napiInstance.exports['__napi_register__WorkspaceContext_struct_39']?.()
-  __napiInstance.exports['__napi_register__WorkspaceContext_impl_48']?.()
-  __napiInstance.exports['__napi_register__WorkspaceErrors_49']?.()
-  __napiInstance.exports['__napi_register__NxWorkspaceFiles_struct_50']?.()
-  __napiInstance.exports['__napi_register__NxWorkspaceFilesExternals_struct_51']?.()
-  __napiInstance.exports['__napi_register__UpdatedWorkspaceFiles_struct_52']?.()
-  __napiInstance.exports['__napi_register__FileMap_struct_53']?.()
-  __napiInstance.exports['__napi_register____test_only_transfer_file_map_54']?.()
+  __napiInstance.exports['__napi_register__FileLock_struct_39']?.()
+  __napiInstance.exports['__napi_register__FileLock_impl_41']?.()
+  __napiInstance.exports['__napi_register__WorkspaceContext_struct_42']?.()
+  __napiInstance.exports['__napi_register__WorkspaceContext_impl_51']?.()
+  __napiInstance.exports['__napi_register__WorkspaceErrors_52']?.()
+  __napiInstance.exports['__napi_register__NxWorkspaceFiles_struct_53']?.()
+  __napiInstance.exports['__napi_register__NxWorkspaceFilesExternals_struct_54']?.()
+  __napiInstance.exports['__napi_register__UpdatedWorkspaceFiles_struct_55']?.()
+  __napiInstance.exports['__napi_register__FileMap_struct_56']?.()
+  __napiInstance.exports['__napi_register____test_only_transfer_file_map_57']?.()
 }
+module.exports.FileLock = __napiModule.exports.FileLock
 module.exports.HashPlanner = __napiModule.exports.HashPlanner
 module.exports.ImportResult = __napiModule.exports.ImportResult
 module.exports.TaskHasher = __napiModule.exports.TaskHasher

package/src/native/tests/__fixtures__/file-lock.fixture.js

@@ -0,0 +1,20 @@
+const { FileLock } = require('../../native-bindings.js');
+const ora = require('ora');
+const tmp = require('os').tmpdir();
+
+(async () => {
+  const lock = new FileLock(
+    require('path').join(tmp, 'nx-unit-tests', 'file-lock-fixture')
+  );
+  if (lock.locked) {
+    const s = ora('Waiting for lock').start();
+    await lock.wait();
+    s.stop();
+    console.log('waited for lock');
+  } else {
+    await lock.lock();
+    await new Promise((resolve) => setTimeout(resolve, 5000));
+    console.log('ran with lock');
+    await lock.unlock();
+  }
+})();

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

@@ -15,7 +15,7 @@ export declare class TargetProjectLocator {
     private tsConfig;
     private paths;
     private typescriptResolutionCache;
-    private packageEntryPointsToProjectMap;
+    private packagesMetadata;
     constructor(nodes: Record<string, ProjectGraphProjectNode>, externalNodes?: Record<string, ProjectGraphExternalNode>, npmResolutionCache?: NpmResolutionCache);
     /**
      * Resolve any workspace or external project that matches the given import expression,
@@ -39,6 +39,7 @@ export declare class TargetProjectLocator {
      * @returns
      */
     findPaths(normalizedImportExpr: string): string[] | undefined;
+    findImportInWorkspaceProjects(importPath: string): string | null;
     findDependencyInWorkspaceProjects(dep: string): string | null;
     private resolveImportWithTypescript;
     private resolveImportWithRequire;

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

@@ -101,7 +101,7 @@ class TargetProjectLocator {
         catch { }
         // fall back to see if it's a locally linked workspace project where the
         // output might not exist yet
-        const localProject = this.findDependencyInWorkspaceProjects(importExpr);
+        const localProject = this.findImportInWorkspaceProjects(importExpr);
         if (localProject) {
             return localProject;
         }
@@ -189,9 +189,17 @@ class TargetProjectLocator {
         }
         return undefined;
     }
+    findImportInWorkspaceProjects(importPath) {
+        this.packagesMetadata ??= (0, packages_1.getWorkspacePackagesMetadata)(this.nodes);
+        if (this.packagesMetadata.entryPointsToProjectMap[importPath]) {
+            return this.packagesMetadata.entryPointsToProjectMap[importPath].name;
+        }
+        const project = (0, packages_1.matchImportToWildcardEntryPointsToProjectMap)(this.packagesMetadata.wildcardEntryPointsToProjectMap, importPath);
+        return project?.name;
+    }
     findDependencyInWorkspaceProjects(dep) {
-        this.packageEntryPointsToProjectMap ??= (0, packages_1.getPackageEntryPointsToProjectMap)(this.nodes);
-        return this.packageEntryPointsToProjectMap[dep]?.name ?? null;
+        this.packagesMetadata ??= (0, packages_1.getWorkspacePackagesMetadata)(this.nodes);
+        return this.packagesMetadata.packageToProjectMap[dep]?.name;
     }
     resolveImportWithTypescript(normalizedImportExpr, filePath) {
         let resolvedModule;

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

@@ -1,3 +1,8 @@
 import type { ProjectGraphProjectNode } from '../../../config/project-graph';
 import type { ProjectConfiguration } from '../../../config/workspace-json-project-json';
-export declare function getPackageEntryPointsToProjectMap<T extends ProjectGraphProjectNode | ProjectConfiguration>(projects: Record<string, T>): Record<string, T>;
+export declare function getWorkspacePackagesMetadata<T extends ProjectGraphProjectNode | ProjectConfiguration>(projects: Record<string, T>): {
+    entryPointsToProjectMap: Record<string, T>;
+    wildcardEntryPointsToProjectMap: Record<string, T>;
+    packageToProjectMap: Record<string, T>;
+};
+export declare function matchImportToWildcardEntryPointsToProjectMap<T extends ProjectGraphProjectNode | ProjectConfiguration>(wildcardEntryPointsToProjectMap: Record<string, T>, importPath: string): T | null;

package/src/plugins/js/utils/packages.js

@@ -1,25 +1,72 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getPackageEntryPointsToProjectMap = getPackageEntryPointsToProjectMap;
+exports.getWorkspacePackagesMetadata = getWorkspacePackagesMetadata;
+exports.matchImportToWildcardEntryPointsToProjectMap = matchImportToWildcardEntryPointsToProjectMap;
+const minimatch_1 = require("minimatch");
 const posix_1 = require("node:path/posix");
-function getPackageEntryPointsToProjectMap(projects) {
-    const result = {};
+function getWorkspacePackagesMetadata(projects) {
+    const entryPointsToProjectMap = {};
+    const wildcardEntryPointsToProjectMap = {};
+    const packageToProjectMap = {};
     for (const project of Object.values(projects)) {
         const metadata = 'data' in project ? project.data.metadata : project.metadata;
         if (!metadata?.js) {
             continue;
         }
-        const { packageName, packageExports } = metadata.js;
-        if (!packageExports || typeof packageExports === 'string') {
-            // no `exports` or it points to a file, which would be the equivalent of
-            // an '.' export, in which case the package name is the entry point
-            result[packageName] = project;
+        const { packageName, packageExports, packageMain, isInPackageManagerWorkspaces, } = metadata.js;
+        packageToProjectMap[packageName] = project;
+        if (!isInPackageManagerWorkspaces) {
+            // it is not included in the package manager workspaces config, so we
+            // skip it since the exports information wouldn't be used by the Node.js
+            // resolution
+            continue;
         }
-        else {
-            for (const entryPoint of Object.keys(packageExports)) {
-                result[(0, posix_1.join)(packageName, entryPoint)] = project;
+        if (packageExports) {
+            if (typeof packageExports === 'string') {
+                // it points to a file, which would be the equivalent of an '.' export,
+                // in which case the package name is the entry point
+                entryPointsToProjectMap[packageName] = project;
+            }
+            else {
+                for (const entryPoint of Object.keys(packageExports)) {
+                    if (packageExports[entryPoint] === null) {
+                        // if the entry point is restricted, we skip it
+                        continue;
+                    }
+                    if (entryPoint.startsWith('.')) {
+                        // it is a relative subpath export
+                        if (entryPoint.includes('*')) {
+                            wildcardEntryPointsToProjectMap[(0, posix_1.join)(packageName, entryPoint)] =
+                                project;
+                        }
+                        else {
+                            entryPointsToProjectMap[(0, posix_1.join)(packageName, entryPoint)] = project;
+                        }
+                    }
+                    else {
+                        // it's a conditional export, so we use the package name as the entry point
+                        // https://nodejs.org/api/packages.html#conditional-exports
+                        entryPointsToProjectMap[packageName] = project;
+                    }
+                }
             }
         }
+        else if (packageMain) {
+            // if there is no exports, but there is a main, the package name is the
+            // entry point
+            entryPointsToProjectMap[packageName] = project;
+        }
+    }
+    return {
+        entryPointsToProjectMap,
+        wildcardEntryPointsToProjectMap,
+        packageToProjectMap,
+    };
+}
+function matchImportToWildcardEntryPointsToProjectMap(wildcardEntryPointsToProjectMap, importPath) {
+    if (!Object.keys(wildcardEntryPointsToProjectMap).length) {
+        return null;
     }
-    return result;
+    const matchingPair = Object.entries(wildcardEntryPointsToProjectMap).find(([key]) => (0, minimatch_1.minimatch)(importPath, key));
+    return matchingPair?.[1];
 }

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

@@ -33,7 +33,7 @@ export declare function getTranspiler(compilerOptions: CompilerOptions, tsConfig
  *
  * @returns cleanup method
  */
-export declare function registerTranspiler(compilerOptions: CompilerOptions, tsConfigRaw?: unknown): () => void;
+export declare function registerTranspiler(compilerOptions: CompilerOptions): () => void;
 /**
  * @param tsConfigPath Adds the paths from a tsconfig file into node resolutions
  * @returns cleanup function

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

@@ -203,7 +203,7 @@ function getTranspiler(compilerOptions, tsConfigRaw) {
  *
  * @returns cleanup method
  */
-function registerTranspiler(compilerOptions, tsConfigRaw) {
+function registerTranspiler(compilerOptions) {
     // Function to register transpiler that returns cleanup function
     const transpiler = getTranspiler(compilerOptions);
     if (!transpiler) {

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

@@ -1,6 +1,7 @@
 import type * as ts from 'typescript';
 import type { Node, SyntaxKind } from 'typescript';
 export declare function readTsConfig(tsConfigPath: string): ts.ParsedCommandLine;
+export declare function readTsConfigOptions(tsConfigPath: string): ts.CompilerOptions;
 /**
  * Find a module based on its import
  *

package/src/plugins/js/utils/typescript.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.readTsConfig = readTsConfig;
+exports.readTsConfigOptions = readTsConfigOptions;
 exports.resolveModuleByImport = resolveModuleByImport;
 exports.getRootTsConfigFileName = getRootTsConfigFileName;
 exports.getRootTsConfigPath = getRootTsConfigPath;

package/src/plugins/package-json/create-nodes.d.ts

@@ -4,13 +4,13 @@ import { PackageJson } from '../../utils/package-json';
 import { CreateNodesV2 } from '../../project-graph/plugins';
 import { PackageJsonConfigurationCache } from '../../../plugins/package-json';
 export declare const createNodesV2: CreateNodesV2;
-export declare function buildPackageJsonWorkspacesMatcher(workspaceRoot: string, readJson: (string: any) => any): (p: string) => boolean;
-export declare function createNodeFromPackageJson(pkgJsonPath: string, workspaceRoot: string, cache: PackageJsonConfigurationCache): {
+export declare function buildPackageJsonWorkspacesMatcher(workspaceRoot: string, readJson: (path: string) => any): (p: string) => boolean;
+export declare function createNodeFromPackageJson(pkgJsonPath: string, workspaceRoot: string, cache: PackageJsonConfigurationCache, isInPackageManagerWorkspaces: boolean): {
     projects: {
         [x: string]: ProjectConfiguration;
     };
 };
-export declare function buildProjectConfigurationFromPackageJson(packageJson: PackageJson, workspaceRoot: string, packageJsonPath: string, nxJson: NxJsonConfiguration): ProjectConfiguration & {
+export declare function buildProjectConfigurationFromPackageJson(packageJson: PackageJson, workspaceRoot: string, packageJsonPath: string, nxJson: NxJsonConfiguration, isInPackageManagerWorkspaces: boolean): ProjectConfiguration & {
     name: string;
 };
 /**

package/src/plugins/package-json/create-nodes.js

@@ -31,12 +31,13 @@ exports.createNodesV2 = [
         };
         const cache = (0, package_json_2.readPackageJsonConfigurationCache)();
         return (0, plugins_1.createNodesFromFiles)((packageJsonPath, options, context) => {
-            if (!isInPackageJsonWorkspaces(packageJsonPath) &&
+            const isInPackageManagerWorkspaces = isInPackageJsonWorkspaces(packageJsonPath);
+            if (!isInPackageManagerWorkspaces &&
                 !isNextToProjectJson(packageJsonPath)) {
                 // Skip if package.json is not part of the package.json workspaces and not next to a project.json.
                 return null;
             }
-            return createNodeFromPackageJson(packageJsonPath, context.workspaceRoot, cache);
+            return createNodeFromPackageJson(packageJsonPath, context.workspaceRoot, cache, isInPackageManagerWorkspaces);
         }, packageJsons, _, context);
     },
 ];
@@ -78,18 +79,13 @@ function buildPackageJsonWorkspacesMatcher(workspaceRoot, readJson) {
          */
         negativePatterns.every((negative) => (0, minimatch_1.minimatch)(p, negative));
 }
-function createNodeFromPackageJson(pkgJsonPath, workspaceRoot, cache) {
+function createNodeFromPackageJson(pkgJsonPath, workspaceRoot, cache, isInPackageManagerWorkspaces) {
     const json = (0, fileutils_1.readJsonFile)((0, node_path_1.join)(workspaceRoot, pkgJsonPath));
     const projectRoot = (0, node_path_1.dirname)(pkgJsonPath);
     const hash = (0, file_hasher_1.hashObject)({
         ...json,
         root: projectRoot,
-        /**
-         * Increment this number to force processing the package.json again. Do it
-         * when the implementation of this plugin is changed and results in different
-         * results for the same package.json contents.
-         */
-        bust: 1,
+        isInPackageManagerWorkspaces,
     });
     const cached = cache[hash];
     if (cached) {
@@ -99,7 +95,7 @@ function createNodeFromPackageJson(pkgJsonPath, workspaceRoot, cache) {
             },
         };
     }
-    const project = buildProjectConfigurationFromPackageJson(json, workspaceRoot, pkgJsonPath, (0, nx_json_1.readNxJson)(workspaceRoot));
+    const project = buildProjectConfigurationFromPackageJson(json, workspaceRoot, pkgJsonPath, (0, nx_json_1.readNxJson)(workspaceRoot), isInPackageManagerWorkspaces);
     cache[hash] = project;
     return {
         projects: {
@@ -107,7 +103,7 @@ function createNodeFromPackageJson(pkgJsonPath, workspaceRoot, cache) {
         },
     };
 }
-function buildProjectConfigurationFromPackageJson(packageJson, workspaceRoot, packageJsonPath, nxJson) {
+function buildProjectConfigurationFromPackageJson(packageJson, workspaceRoot, packageJsonPath, nxJson, isInPackageManagerWorkspaces) {
     const normalizedPath = packageJsonPath.split('\\').join('/');
     const projectRoot = (0, node_path_1.dirname)(normalizedPath);
     const siblingProjectJson = tryReadJson((0, node_path_1.join)(workspaceRoot, projectRoot, 'project.json'));
@@ -135,7 +131,7 @@ function buildProjectConfigurationFromPackageJson(packageJson, workspaceRoot, pa
         ...packageJson.nx,
         targets: (0, package_json_1.readTargetsFromPackageJson)(packageJson, nxJson),
         tags: (0, package_json_1.getTagsFromPackageJson)(packageJson),
-        metadata: (0, package_json_1.getMetadataFromPackageJson)(packageJson),
+        metadata: (0, package_json_1.getMetadataFromPackageJson)(packageJson, isInPackageManagerWorkspaces),
     };
     if (nxJson?.workspaceLayout?.appsDir != nxJson?.workspaceLayout?.libsDir &&
         nxJson?.workspaceLayout?.appsDir &&

package/src/project-graph/error-types.d.ts

@@ -2,10 +2,14 @@ import { ConfigurationResult, ConfigurationSourceMaps } from './utils/project-co
 import { ProjectConfiguration } from '../config/workspace-json-project-json';
 import { ProjectGraph } from '../config/project-graph';
 import { CreateNodesFunctionV2 } from './plugins/public-api';
+export type ProjectGraphErrorTypes = AggregateCreateNodesError | MergeNodesError | CreateMetadataError | ProjectsWithNoNameError | MultipleProjectsWithSameNameError | ProcessDependenciesError | WorkspaceValidityError;
+export declare class StaleProjectGraphCacheError extends Error {
+    constructor();
+}
 export declare class ProjectGraphError extends Error {
     #private;
     private readonly errors;
-    constructor(errors: Array<AggregateCreateNodesError | MergeNodesError | ProjectsWithNoNameError | MultipleProjectsWithSameNameError | ProcessDependenciesError | CreateMetadataError | WorkspaceValidityError>, partialProjectGraph: ProjectGraph, partialSourceMaps: ConfigurationSourceMaps);
+    constructor(errors: Array<ProjectGraphErrorTypes>, partialProjectGraph: ProjectGraph, partialSourceMaps: ConfigurationSourceMaps | null);
     /**
      * The daemon cannot throw errors which contain methods as they are not serializable.
      *
@@ -19,7 +23,7 @@ export declare class ProjectGraphError extends Error {
      */
     getPartialProjectGraph(): ProjectGraph;
     getPartialSourcemaps(): ConfigurationSourceMaps;
-    getErrors(): (AggregateCreateNodesError | MergeNodesError | ProjectsWithNoNameError | MultipleProjectsWithSameNameError | ProcessDependenciesError | CreateMetadataError | WorkspaceValidityError)[];
+    getErrors(): ProjectGraphErrorTypes[];
 }
 export declare class MultipleProjectsWithSameNameError extends Error {
     conflicts: Map<string, string[]>;

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

@@ -1,7 +1,7 @@
 "use strict";
 var _ProjectGraphError_partialProjectGraph, _ProjectGraphError_partialSourceMaps;
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.LoadPluginError = exports.DaemonProjectGraphError = exports.AggregateProjectGraphError = exports.WorkspaceValidityError = exports.ProcessDependenciesError = exports.CreateMetadataError = exports.MergeNodesError = exports.AggregateCreateNodesError = exports.ProjectConfigurationsError = exports.ProjectWithNoNameError = exports.ProjectsWithNoNameError = exports.ProjectWithExistingNameError = exports.MultipleProjectsWithSameNameError = exports.ProjectGraphError = void 0;
+exports.LoadPluginError = exports.DaemonProjectGraphError = exports.AggregateProjectGraphError = exports.WorkspaceValidityError = exports.ProcessDependenciesError = exports.CreateMetadataError = exports.MergeNodesError = exports.AggregateCreateNodesError = exports.ProjectConfigurationsError = exports.ProjectWithNoNameError = exports.ProjectsWithNoNameError = exports.ProjectWithExistingNameError = exports.MultipleProjectsWithSameNameError = exports.ProjectGraphError = exports.StaleProjectGraphCacheError = void 0;
 exports.isProjectWithExistingNameError = isProjectWithExistingNameError;
 exports.isMultipleProjectsWithSameNameError = isMultipleProjectsWithSameNameError;
 exports.isProjectsWithNoNameError = isProjectsWithNoNameError;
@@ -14,6 +14,12 @@ exports.isCreateMetadataError = isCreateMetadataError;
 exports.isAggregateCreateNodesError = isAggregateCreateNodesError;
 exports.isMergeNodesError = isMergeNodesError;
 const tslib_1 = require("tslib");
+class StaleProjectGraphCacheError extends Error {
+    constructor() {
+        super('The project graph cache was stale. Ensure that it has been recently created before using `readCachedProjectGraph`.');
+    }
+}
+exports.StaleProjectGraphCacheError = StaleProjectGraphCacheError;
 class ProjectGraphError extends Error {
     constructor(errors, partialProjectGraph, partialSourceMaps) {
         const messageFragments = ['Failed to process project graph.'];

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

@@ -154,6 +154,7 @@ function getProjectsSync(root, nxJson) {
         ...(0, package_json_1.getGlobPatternsFromPackageManagerWorkspaces)(root, fileutils_1.readJsonFile),
     ];
     const projectFiles = (0, workspace_context_1.globWithWorkspaceContextSync)(root, patterns);
+    const isInPackageJsonWorkspaces = (0, package_json_1.buildPackageJsonWorkspacesMatcher)(root, (f) => (0, fileutils_1.readJsonFile)((0, path_1.join)(root, f)));
     const rootMap = {};
     for (const projectFile of projectFiles) {
         if ((0, path_1.basename)(projectFile) === 'project.json') {
@@ -163,7 +164,7 @@ function getProjectsSync(root, nxJson) {
         }
         else if ((0, path_1.basename)(projectFile) === 'package.json') {
             const packageJson = (0, fileutils_1.readJsonFile)(projectFile);
-            const config = (0, package_json_1.buildProjectConfigurationFromPackageJson)(packageJson, root, projectFile, nxJson);
+            const config = (0, package_json_1.buildProjectConfigurationFromPackageJson)(packageJson, root, projectFile, nxJson, isInPackageJsonWorkspaces(projectFile));
             if (!rootMap[config.root]) {
                 (0, project_configuration_utils_1.mergeProjectConfigurationIntoRootMap)(rootMap, 
                 // Inferred targets, tags, etc don't show up when running generators

package/src/project-graph/nx-deps-cache.d.ts

@@ -1,6 +1,8 @@
 import { NxJsonConfiguration } from '../config/nx-json';
 import { FileData, FileMap, ProjectGraph } from '../config/project-graph';
 import { ProjectConfiguration } from '../config/workspace-json-project-json';
+import { ConfigurationSourceMaps } from './utils/project-configuration-utils';
+import { ProjectGraphErrorTypes } from './error-types';
 export interface FileMapCache {
     version: string;
     nxVersion: string;
@@ -11,9 +13,11 @@ export interface FileMapCache {
 }
 export declare const nxProjectGraph: string;
 export declare const nxFileMap: string;
+export declare const nxSourceMaps: string;
 export declare function ensureCacheDirectory(): void;
 export declare function readFileMapCache(): null | FileMapCache;
-export declare function readProjectGraphCache(): null | ProjectGraph;
+export declare function readProjectGraphCache(minimumComputedAt?: number): null | ProjectGraph;
+export declare function readSourceMapsCache(): null | ConfigurationSourceMaps;
 export declare function createProjectFileMapCache(nxJson: NxJsonConfiguration<'*' | string[]>, packageJsonDeps: Record<string, string>, fileMap: FileMap, tsConfig: {
     compilerOptions?: {
         paths?: {
@@ -21,7 +25,7 @@ export declare function createProjectFileMapCache(nxJson: NxJsonConfiguration<'*
         };
     };
 }): FileMapCache;
-export declare function writeCache(cache: FileMapCache, projectGraph: ProjectGraph): void;
+export declare function writeCache(cache: FileMapCache, projectGraph: ProjectGraph, sourceMaps: ConfigurationSourceMaps, errors: ProjectGraphErrorTypes[]): void;
 export declare function shouldRecomputeWholeGraph(cache: FileMapCache, packageJsonDeps: Record<string, string>, projects: Record<string, ProjectConfiguration>, nxJson: NxJsonConfiguration, tsConfig: {
     compilerOptions: {
         paths: {

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

@@ -1,9 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.nxFileMap = exports.nxProjectGraph = void 0;
+exports.nxSourceMaps = exports.nxFileMap = exports.nxProjectGraph = void 0;
 exports.ensureCacheDirectory = ensureCacheDirectory;
 exports.readFileMapCache = readFileMapCache;
 exports.readProjectGraphCache = readProjectGraphCache;
+exports.readSourceMapsCache = readSourceMapsCache;
 exports.createProjectFileMapCache = createProjectFileMapCache;
 exports.writeCache = writeCache;
 exports.shouldRecomputeWholeGraph = shouldRecomputeWholeGraph;
@@ -14,8 +15,10 @@ 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");
+const error_types_1 = require("./error-types");
 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');
+exports.nxSourceMaps = (0, path_1.join)(cache_directory_1.workspaceDataDirectory, 'source-maps.json');
 function ensureCacheDirectory() {
     try {
         if (!(0, node_fs_1.existsSync)(cache_directory_1.workspaceDataDirectory)) {
@@ -55,21 +58,62 @@ function readFileMapCache() {
     perf_hooks_1.performance.measure('read cache', 'read cache:start', 'read cache:end');
     return data ?? null;
 }
-function readProjectGraphCache() {
+function readProjectGraphCache(minimumComputedAt) {
     perf_hooks_1.performance.mark('read project-graph:start');
     ensureCacheDirectory();
-    let data = null;
     try {
         if ((0, fileutils_1.fileExists)(exports.nxProjectGraph)) {
-            data = (0, fileutils_1.readJsonFile)(exports.nxProjectGraph);
+            const { computedAt, errors, ...projectGraphCache } = (0, fileutils_1.readJsonFile)(exports.nxProjectGraph);
+            if (minimumComputedAt &&
+                (!computedAt || computedAt < minimumComputedAt)) {
+                throw new error_types_1.StaleProjectGraphCacheError();
+            }
+            if (errors && errors.length > 0) {
+                if (!minimumComputedAt) {
+                    // If you didn't pass minimum computed at, we do not know if
+                    // the errors on the cached graph would be relevant to what you
+                    // are running. Prior to adding error handling here, the graph
+                    // would not have been written to the cache. As such, this matches
+                    // existing behavior of the public API.
+                    return null;
+                }
+                throw new error_types_1.ProjectGraphError(errors, projectGraphCache, readSourceMapsCache());
+            }
+            return projectGraphCache;
+        }
+        else {
+            return null;
         }
     }
     catch (error) {
+        if (error instanceof error_types_1.StaleProjectGraphCacheError ||
+            error instanceof error_types_1.ProjectGraphError) {
+            throw error;
+        }
         console.log(`Error reading '${exports.nxProjectGraph}'. Continue the process without the cache.`);
         console.log(error);
+        return null;
+    }
+    finally {
+        perf_hooks_1.performance.mark('read project-graph:end');
+        perf_hooks_1.performance.measure('read cache', 'read project-graph:start', 'read project-graph:end');
     }
-    perf_hooks_1.performance.mark('read project-graph:end');
-    perf_hooks_1.performance.measure('read cache', 'read project-graph:start', 'read project-graph:end');
+}
+function readSourceMapsCache() {
+    perf_hooks_1.performance.mark('read source-maps:start');
+    ensureCacheDirectory();
+    let data = null;
+    try {
+        if ((0, fileutils_1.fileExists)(exports.nxSourceMaps)) {
+            data = (0, fileutils_1.readJsonFile)(exports.nxSourceMaps);
+        }
+    }
+    catch (error) {
+        console.log(`Error reading '${exports.nxSourceMaps}'. Continue the process without the cache.`);
+        console.log(error);
+    }
+    perf_hooks_1.performance.mark('read source-maps:end');
+    perf_hooks_1.performance.measure('read cache', 'read source-maps:start', 'read source-maps:end');
     return data ?? null;
 }
 function createProjectFileMapCache(nxJson, packageJsonDeps, fileMap, tsConfig) {
@@ -85,7 +129,7 @@ function createProjectFileMapCache(nxJson, packageJsonDeps, fileMap, tsConfig) {
     };
     return newValue;
 }
-function writeCache(cache, projectGraph) {
+function writeCache(cache, projectGraph, sourceMaps, errors) {
     perf_hooks_1.performance.mark('write cache:start');
     let retry = 1;
     let done = false;
@@ -98,11 +142,23 @@ function writeCache(cache, projectGraph) {
         const unique = (Math.random().toString(16) + '0000000').slice(2, 10);
         const tmpProjectGraphPath = `${exports.nxProjectGraph}~${unique}`;
         const tmpFileMapPath = `${exports.nxFileMap}~${unique}`;
+        const tmpSourceMapPath = `${exports.nxSourceMaps}~${unique}`;
         try {
-            (0, fileutils_1.writeJsonFile)(tmpProjectGraphPath, projectGraph);
+            (0, fileutils_1.writeJsonFile)(tmpProjectGraphPath, {
+                ...projectGraph,
+                errors,
+                computedAt: Date.now(),
+            });
             (0, node_fs_1.renameSync)(tmpProjectGraphPath, exports.nxProjectGraph);
-            (0, fileutils_1.writeJsonFile)(tmpFileMapPath, cache);
-            (0, node_fs_1.renameSync)(tmpFileMapPath, exports.nxFileMap);
+            (0, fileutils_1.writeJsonFile)(tmpSourceMapPath, sourceMaps);
+            (0, node_fs_1.renameSync)(tmpSourceMapPath, exports.nxSourceMaps);
+            // only write the file map if there are no errors
+            // if there were errors, the errors make the filemap invalid
+            // TODO: We should be able to keep the valid part of the filemap if the errors being thrown told us which parts of the filemap were invalid
+            if (errors.length === 0) {
+                (0, fileutils_1.writeJsonFile)(tmpFileMapPath, cache);
+                (0, node_fs_1.renameSync)(tmpFileMapPath, exports.nxFileMap);
+            }
             done = true;
         }
         catch (err) {

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

@@ -57,27 +57,23 @@ class LoadedNxPlugin {
         if (plugin.preTasksExecution) {
             this.preTasksExecution = async (context) => {
                 const updates = {};
-                let revokeFn;
+                let originalEnv = process.env;
                 if ((0, enabled_1.isIsolationEnabled)() || (0, client_1.isDaemonEnabled)()) {
-                    const { proxy, revoke } = Proxy.revocable(process.env, {
+                    process.env = new Proxy(originalEnv, {
                         set: (target, key, value) => {
                             target[key] = value;
                             updates[key] = value;
                             return true;
                         },
                     });
-                    process.env = proxy;
-                    revokeFn = revoke;
                 }
                 await plugin.preTasksExecution(this.options, context);
-                if (revokeFn) {
-                    revokeFn();
-                }
+                process.env = originalEnv;
                 return updates;
             };
-            if (plugin.postTasksExecution) {
-                this.postTasksExecution = async (context) => plugin.postTasksExecution(this.options, context);
-            }
+        }
+        if (plugin.postTasksExecution) {
+            this.postTasksExecution = async (context) => plugin.postTasksExecution(this.options, context);
         }
     }
 }

package/src/project-graph/plugins/resolve-plugin.js

@@ -83,6 +83,7 @@ function lookupLocalPlugin(importPath, projects, root = workspace_root_1.workspa
     return { path: path.join(root, projectConfig.root), projectConfig };
 }
 let packageEntryPointsToProjectMap;
+let wildcardEntryPointsToProjectMap;
 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)))) ?? [];
@@ -101,11 +102,19 @@ function findNxProjectForImportPath(importPath, projects, root = workspace_root_
             }
         }
     }
-    packageEntryPointsToProjectMap ??=
-        (0, packages_1.getPackageEntryPointsToProjectMap)(projects);
+    if (!packageEntryPointsToProjectMap && !wildcardEntryPointsToProjectMap) {
+        ({
+            entryPointsToProjectMap: packageEntryPointsToProjectMap,
+            wildcardEntryPointsToProjectMap,
+        } = (0, packages_1.getWorkspacePackagesMetadata)(projects));
+    }
     if (packageEntryPointsToProjectMap[importPath]) {
         return packageEntryPointsToProjectMap[importPath];
     }
+    const project = (0, packages_1.matchImportToWildcardEntryPointsToProjectMap)(wildcardEntryPointsToProjectMap, importPath);
+    if (project) {
+        return project;
+    }
     logger_1.logger.verbose('Unable to find local plugin', possibleTsPaths, projectRootMappings);
     throw new Error('Unable to resolve local plugin with import path ' + importPath);
 }

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

@@ -23,16 +23,16 @@ function registerPluginTSTranspiler() {
     if (!tsConfigName) {
         return;
     }
-    const tsConfig = tsConfigName
-        ? (0, typescript_1.readTsConfig)(tsConfigName)
+    const tsConfigOptions = tsConfigName
+        ? (0, typescript_1.readTsConfigOptions)(tsConfigName)
         : {};
     const cleanupFns = [
         (0, register_1.registerTsConfigPaths)(tsConfigName),
         (0, register_1.registerTranspiler)({
             experimentalDecorators: true,
             emitDecoratorMetadata: true,
-            ...tsConfig.options,
-        }, tsConfig.raw),
+            ...tsConfigOptions,
+        }),
     ];
     exports.unregisterPluginTSTranspiler = () => {
         cleanupFns.forEach((fn) => fn?.());

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

@@ -2,9 +2,11 @@ import { ProjectGraph } from '../config/project-graph';
 import { ProjectConfiguration, ProjectsConfigurations } from '../config/workspace-json-project-json';
 /**
  * Synchronously reads the latest cached copy of the workspace's ProjectGraph.
+ *
+ * @param {number} [minimumComputedAt] - The minimum timestamp that the cached ProjectGraph must have been computed at.
  * @throws {Error} if there is no cached ProjectGraph to read from
  */
-export declare function readCachedProjectGraph(): ProjectGraph;
+export declare function readCachedProjectGraph(minimumComputedAt?: number): ProjectGraph;
 export declare function readCachedProjectConfiguration(projectName: string): ProjectConfiguration;
 /**
  * Get the {@link ProjectsConfigurations} from the {@link ProjectGraph}

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

@@ -21,12 +21,18 @@ const nx_deps_cache_1 = require("./nx-deps-cache");
 const retrieve_workspace_files_1 = require("./utils/retrieve-workspace-files");
 const get_plugins_1 = require("./plugins/get-plugins");
 const logger_1 = require("../utils/logger");
+const native_1 = require("../native");
+const path_1 = require("path");
+const cache_directory_1 = require("../utils/cache-directory");
+const delayed_spinner_1 = require("../utils/delayed-spinner");
 /**
  * Synchronously reads the latest cached copy of the workspace's ProjectGraph.
+ *
+ * @param {number} [minimumComputedAt] - The minimum timestamp that the cached ProjectGraph must have been computed at.
  * @throws {Error} if there is no cached ProjectGraph to read from
  */
-function readCachedProjectGraph() {
-    const projectGraphCache = (0, nx_deps_cache_1.readProjectGraphCache)();
+function readCachedProjectGraph(minimumComputedAt) {
+    const projectGraphCache = (0, nx_deps_cache_1.readProjectGraphCache)(minimumComputedAt);
     if (!projectGraphCache) {
         const angularSpecificError = (0, fileutils_1.fileExists)(`${workspace_root_1.workspaceRoot}/angular.json`)
             ? (0, strip_indents_1.stripIndents) `
@@ -120,13 +126,13 @@ async function buildProjectGraphAndSourceMapsWithoutDaemon() {
         ...(projectConfigurationsError?.errors ?? []),
         ...(projectGraphError?.errors ?? []),
     ];
+    if (cacheEnabled) {
+        (0, nx_deps_cache_1.writeCache)(projectFileMapCache, projectGraph, sourceMaps, errors);
+    }
     if (errors.length > 0) {
         throw new error_types_1.ProjectGraphError(errors, projectGraph, sourceMaps);
     }
     else {
-        if (cacheEnabled) {
-            (0, nx_deps_cache_1.writeCache)(projectFileMapCache, projectGraph);
-        }
         return { projectGraph, sourceMaps };
     }
 }
@@ -143,7 +149,7 @@ function handleProjectGraphError(opts, e) {
                 bodyLines: bodyLines,
             });
         }
-        else {
+        else if (typeof e.message === 'string') {
             const lines = e.message.split('\n');
             output_1.output.error({
                 title: lines[0],
@@ -153,12 +159,25 @@ function handleProjectGraphError(opts, e) {
                 console.error(e);
             }
         }
+        else {
+            console.error(e);
+        }
         process.exit(1);
     }
     else {
         throw e;
     }
 }
+async function readCachedGraphAndHydrateFileMap(minimumComputedAt) {
+    const graph = readCachedProjectGraph(minimumComputedAt);
+    const projectRootMap = Object.fromEntries(Object.entries(graph.nodes).map(([project, { data }]) => [
+        data.root,
+        project,
+    ]));
+    const { allWorkspaceFiles, fileMap, rustReferences } = await (0, retrieve_workspace_files_1.retrieveWorkspaceFiles)(workspace_root_1.workspaceRoot, projectRootMap);
+    (0, build_project_graph_1.hydrateFileMap)(fileMap, allWorkspaceFiles, rustReferences);
+    return graph;
+}
 /**
  * Computes and returns a ProjectGraph.
  *
@@ -186,17 +205,14 @@ async function createProjectGraphAsync(opts = {
 }) {
     if (process.env.NX_FORCE_REUSE_CACHED_GRAPH === 'true') {
         try {
-            const graph = readCachedProjectGraph();
-            const projectRootMap = Object.fromEntries(Object.entries(graph.nodes).map(([project, { data }]) => [
-                data.root,
-                project,
-            ]));
-            const { allWorkspaceFiles, fileMap, rustReferences } = await (0, retrieve_workspace_files_1.retrieveWorkspaceFiles)(workspace_root_1.workspaceRoot, projectRootMap);
-            (0, build_project_graph_1.hydrateFileMap)(fileMap, allWorkspaceFiles, rustReferences);
-            return graph;
             // If no cached graph is found, we will fall through to the normal flow
+            const graph = await readCachedGraphAndHydrateFileMap();
+            return graph;
         }
         catch (e) {
+            if (e instanceof error_types_1.ProjectGraphError) {
+                throw e;
+            }
             logger_1.logger.verbose('Unable to use cached project graph', e);
         }
     }
@@ -209,6 +225,48 @@ async function createProjectGraphAndSourceMapsAsync(opts = {
 }) {
     perf_hooks_1.performance.mark('create-project-graph-async:start');
     if (!client_1.daemonClient.enabled()) {
+        const lock = !native_1.IS_WASM
+            ? new native_1.FileLock((0, path_1.join)(cache_directory_1.workspaceDataDirectory, 'project-graph.lock'))
+            : null;
+        let locked = lock?.locked;
+        while (locked) {
+            logger_1.logger.verbose('Waiting for graph construction in another process to complete');
+            const spinner = new delayed_spinner_1.DelayedSpinner('Waiting for graph construction in another process to complete');
+            const start = Date.now();
+            await lock.wait();
+            spinner.cleanup();
+            // Note: This will currently throw if any of the caches are missing...
+            // It would be nice if one of the processes that was waiting for the lock
+            // could pick up the slack and build the graph if it's missing, but
+            // we wouldn't want either of the below to happen:
+            // - All of the waiting processes to build the graph
+            // - Even one of the processes building the graph on a legitimate error
+            try {
+                // Ensuring that computedAt was after this process started
+                // waiting for the graph to complete, means that the graph
+                // was computed by the process was already working.
+                const graph = await readCachedGraphAndHydrateFileMap(start);
+                const sourceMaps = (0, nx_deps_cache_1.readSourceMapsCache)();
+                if (!sourceMaps) {
+                    throw new Error('The project graph was computed in another process, but the source maps are missing.');
+                }
+                return {
+                    projectGraph: graph,
+                    sourceMaps,
+                };
+            }
+            catch (e) {
+                // If the error is that the cached graph is stale after unlock,
+                // the process that was working on the graph must have been canceled,
+                // so we will fall through to the normal flow to ensure
+                // its created by one of the processes that was waiting
+                if (!(e instanceof error_types_1.StaleProjectGraphCacheError)) {
+                    throw e;
+                }
+            }
+            locked = lock.check();
+        }
+        lock?.lock();
         try {
             const res = await buildProjectGraphAndSourceMapsWithoutDaemon();
             perf_hooks_1.performance.measure('create-project-graph-async >> retrieve-project-configurations', 'retrieve-project-configurations:start', 'retrieve-project-configurations:end');
@@ -221,6 +279,9 @@ async function createProjectGraphAndSourceMapsAsync(opts = {
         catch (e) {
             handleProjectGraphError(opts, e);
         }
+        finally {
+            lock.unlock();
+        }
     }
     else {
         try {

package/src/tasks-runner/cache.js

@@ -437,18 +437,19 @@ function tryAndRetry(fn) {
     let attempts = 0;
     // Generate a random number between 2 and 4 to raise to the power of attempts
     const baseExponent = Math.random() * 2 + 2;
+    const baseTimeout = 15;
     const _try = async () => {
         try {
             attempts++;
             return await fn();
         }
         catch (e) {
-            // Max time is 5 * 4^3 = 20480ms
+            // Max time is 15 * (4 + 4² + 4³ + 4⁴ + 4⁵) = 20460ms
             if (attempts === 6) {
                 // After enough attempts, throw the error
                 throw e;
             }
-            await new Promise((res) => setTimeout(res, baseExponent ** attempts));
+            await new Promise((res) => setTimeout(res, baseTimeout * baseExponent ** attempts));
             return await _try();
         }
     };

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

@@ -72,7 +72,7 @@ export declare function readNxMigrateConfig(json: Partial<PackageJson>): NxMigra
     packageGroup?: ArrayPackageGroup;
 };
 export declare function buildTargetFromScript(script: string, scripts: Record<string, string>, packageManagerCommand: PackageManagerCommands): TargetConfiguration;
-export declare function getMetadataFromPackageJson(packageJson: PackageJson): ProjectMetadata;
+export declare function getMetadataFromPackageJson(packageJson: PackageJson, isInPackageManagerWorkspaces: boolean): ProjectMetadata;
 export declare function getTagsFromPackageJson(packageJson: PackageJson): string[];
 export declare function readTargetsFromPackageJson(packageJson: PackageJson, nxJson: NxJsonConfiguration): Record<string, TargetConfiguration<any>>;
 /**

package/src/utils/package-json.js

@@ -57,8 +57,8 @@ function buildTargetFromScript(script, scripts = {}, packageManagerCommand) {
     };
 }
 let packageManagerCommand;
-function getMetadataFromPackageJson(packageJson) {
-    const { scripts, nx, description, name, exports } = packageJson;
+function getMetadataFromPackageJson(packageJson, isInPackageManagerWorkspaces) {
+    const { scripts, nx, description, name, exports, main } = packageJson;
     const includedScripts = nx?.includedScripts || Object.keys(scripts ?? {});
     return {
         targetGroups: {
@@ -68,6 +68,8 @@ function getMetadataFromPackageJson(packageJson) {
         js: {
             packageName: name,
             packageExports: exports,
+            packageMain: main,
+            isInPackageManagerWorkspaces,
         },
     };
 }