nx 20.5.0-canary.20250201-05e0679 → 21.0.0-beta.0

package/src/executors/run-commands/running-tasks.js

@@ -0,0 +1,349 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SeriallyRunningTasks = exports.ParallelRunningTasks = void 0;
+const child_process_1 = require("child_process");
+const run_commands_impl_1 = require("./run-commands.impl");
+const path_1 = require("path");
+const chalk = require("chalk");
+const npm_run_path_1 = require("npm-run-path");
+const task_env_1 = require("../../tasks-runner/task-env");
+const treeKill = require("tree-kill");
+class ParallelRunningTasks {
+    constructor(options, context) {
+        this.exitCallbacks = [];
+        this.childProcesses = options.commands.map((commandConfig) => new RunningNodeProcess(commandConfig, options.color, calculateCwd(options.cwd, context), options.env ?? {}, options.readyWhenStatus, options.streamOutput, options.envFile));
+        this.readyWhenStatus = options.readyWhenStatus;
+        this.streamOutput = options.streamOutput;
+        this.run();
+    }
+    async getResults() {
+        return new Promise((res) => {
+            this.onExit((code, terminalOutput) => {
+                res({ code, terminalOutput });
+            });
+        });
+    }
+    onExit(cb) {
+        this.exitCallbacks.push(cb);
+    }
+    send(message) {
+        for (const childProcess of this.childProcesses) {
+            childProcess.send(message);
+        }
+    }
+    async kill(signal) {
+        await Promise.all(this.childProcesses.map(async (p) => {
+            try {
+                return p.kill();
+            }
+            catch (e) {
+                console.error(`Unable to terminate "${p.command}"\nError:`, e);
+            }
+        }));
+    }
+    async run() {
+        if (this.readyWhenStatus.length) {
+            let { childProcess, result: { code, terminalOutput }, } = await Promise.race(this.childProcesses.map((childProcess) => new Promise((res) => {
+                childProcess.onExit((code, terminalOutput) => {
+                    res({
+                        childProcess,
+                        result: { code, terminalOutput },
+                    });
+                });
+            })));
+            if (code !== 0) {
+                const output = `Warning: command "${childProcess.command}" exited with non-zero status code`;
+                terminalOutput += output;
+                if (this.streamOutput) {
+                    process.stderr.write(output);
+                }
+            }
+            for (const cb of this.exitCallbacks) {
+                cb(code, terminalOutput);
+            }
+        }
+        else {
+            const results = await Promise.all(this.childProcesses.map((childProcess) => childProcess.getResults().then((result) => ({
+                childProcess,
+                result,
+            }))));
+            let terminalOutput = results
+                .map((r) => r.result.terminalOutput)
+                .join('\r\n');
+            const failed = results.filter((result) => result.result.code !== 0);
+            if (failed.length > 0) {
+                const output = failed
+                    .map((failedResult) => `Warning: command "${failedResult.childProcess.command}" exited with non-zero status code`)
+                    .join('\r\n');
+                terminalOutput += output;
+                if (this.streamOutput) {
+                    process.stderr.write(output);
+                }
+                for (const cb of this.exitCallbacks) {
+                    cb(1, terminalOutput);
+                }
+            }
+            else {
+                for (const cb of this.exitCallbacks) {
+                    cb(0, terminalOutput);
+                }
+            }
+        }
+    }
+}
+exports.ParallelRunningTasks = ParallelRunningTasks;
+class SeriallyRunningTasks {
+    constructor(options, context, pseudoTerminal) {
+        this.pseudoTerminal = pseudoTerminal;
+        this.terminalOutput = '';
+        this.currentProcess = null;
+        this.exitCallbacks = [];
+        this.code = 0;
+        this.run(options, context)
+            .catch((e) => {
+            this.error = e;
+        })
+            .finally(() => {
+            for (const cb of this.exitCallbacks) {
+                cb(this.code, this.terminalOutput);
+            }
+        });
+    }
+    getResults() {
+        return new Promise((res, rej) => {
+            this.onExit((code) => {
+                if (this.error) {
+                    rej(this.error);
+                }
+                else {
+                    res({ code, terminalOutput: this.terminalOutput });
+                }
+            });
+        });
+    }
+    onExit(cb) {
+        this.exitCallbacks.push(cb);
+    }
+    send(message) {
+        throw new Error('Not implemented');
+    }
+    kill(signal) {
+        return this.currentProcess.kill(signal);
+    }
+    async run(options, context) {
+        for (const c of options.commands) {
+            const childProcess = await this.createProcess(c, [], options.color, calculateCwd(options.cwd, context), options.processEnv ?? options.env ?? {}, false, options.usePty, options.streamOutput, options.tty, options.envFile);
+            this.currentProcess = childProcess;
+            let { code, terminalOutput } = await childProcess.getResults();
+            this.terminalOutput += terminalOutput;
+            this.code = code;
+            if (code !== 0) {
+                const output = `Warning: command "${c.command}" exited with non-zero status code`;
+                terminalOutput += output;
+                if (options.streamOutput) {
+                    process.stderr.write(output);
+                }
+                this.terminalOutput += terminalOutput;
+                // Stop running commands
+                break;
+            }
+        }
+    }
+    async createProcess(commandConfig, readyWhenStatus = [], color, cwd, env, isParallel, usePty = true, streamOutput = true, tty, envFile) {
+        // The rust runCommand is always a tty, so it will not look nice in parallel and if we need prefixes
+        // currently does not work properly in windows
+        if (this.pseudoTerminal &&
+            process.env.NX_NATIVE_COMMAND_RUNNER !== 'false' &&
+            !commandConfig.prefix &&
+            readyWhenStatus.length === 0 &&
+            !isParallel &&
+            usePty) {
+            return createProcessWithPseudoTty(this.pseudoTerminal, commandConfig, color, cwd, env, streamOutput, tty, envFile);
+        }
+        return new RunningNodeProcess(commandConfig, color, cwd, env, readyWhenStatus, streamOutput, envFile);
+    }
+}
+exports.SeriallyRunningTasks = SeriallyRunningTasks;
+class RunningNodeProcess {
+    constructor(commandConfig, color, cwd, env, readyWhenStatus, streamOutput = true, envFile) {
+        this.readyWhenStatus = readyWhenStatus;
+        this.terminalOutput = '';
+        this.exitCallbacks = [];
+        env = processEnv(color, cwd, env, envFile);
+        this.command = commandConfig.command;
+        this.terminalOutput = chalk.dim('> ') + commandConfig.command + '\r\n\r\n';
+        if (streamOutput) {
+            process.stdout.write(this.terminalOutput);
+        }
+        this.childProcess = (0, child_process_1.exec)(commandConfig.command, {
+            maxBuffer: run_commands_impl_1.LARGE_BUFFER,
+            env,
+            cwd,
+            windowsHide: false,
+        });
+        this.addListeners(commandConfig, streamOutput);
+    }
+    getResults() {
+        return new Promise((res) => {
+            this.onExit((code, terminalOutput) => {
+                res({ code, terminalOutput });
+            });
+        });
+    }
+    onExit(cb) {
+        this.exitCallbacks.push(cb);
+    }
+    send(message) {
+        this.childProcess.send(message);
+    }
+    kill(signal) {
+        return new Promise((res, rej) => {
+            treeKill(this.childProcess.pid, signal, (err) => {
+                if (err) {
+                    rej(err);
+                }
+                else {
+                    res();
+                }
+            });
+        });
+    }
+    addListeners(commandConfig, streamOutput) {
+        this.childProcess.stdout.on('data', (data) => {
+            const output = addColorAndPrefix(data, commandConfig);
+            this.terminalOutput += output;
+            if (streamOutput) {
+                process.stdout.write(output);
+            }
+            if (this.readyWhenStatus.length &&
+                isReady(this.readyWhenStatus, data.toString())) {
+                for (const cb of this.exitCallbacks) {
+                    cb(0, this.terminalOutput);
+                }
+            }
+        });
+        this.childProcess.stderr.on('data', (err) => {
+            const output = addColorAndPrefix(err, commandConfig);
+            this.terminalOutput += output;
+            if (streamOutput) {
+                process.stderr.write(output);
+            }
+            if (this.readyWhenStatus.length &&
+                isReady(this.readyWhenStatus, err.toString())) {
+                for (const cb of this.exitCallbacks) {
+                    cb(1, this.terminalOutput);
+                }
+            }
+        });
+        this.childProcess.on('error', (err) => {
+            const output = addColorAndPrefix(err.toString(), commandConfig);
+            this.terminalOutput += output;
+            if (streamOutput) {
+                process.stderr.write(output);
+            }
+            for (const cb of this.exitCallbacks) {
+                cb(1, this.terminalOutput);
+            }
+        });
+        this.childProcess.on('exit', (code) => {
+            if (!this.readyWhenStatus.length || isReady(this.readyWhenStatus)) {
+                for (const cb of this.exitCallbacks) {
+                    cb(code, this.terminalOutput);
+                }
+            }
+        });
+    }
+}
+async function createProcessWithPseudoTty(pseudoTerminal, commandConfig, color, cwd, env, streamOutput = true, tty, envFile) {
+    let terminalOutput = chalk.dim('> ') + commandConfig.command + '\r\n\r\n';
+    if (streamOutput) {
+        process.stdout.write(terminalOutput);
+    }
+    env = processEnv(color, cwd, env, envFile);
+    const childProcess = pseudoTerminal.runCommand(commandConfig.command, {
+        cwd,
+        jsEnv: env,
+        quiet: !streamOutput,
+        tty,
+    });
+    childProcess.onOutput((output) => {
+        terminalOutput += output;
+    });
+    return childProcess;
+}
+function addColorAndPrefix(out, config) {
+    if (config.prefix) {
+        out = out
+            .split('\n')
+            .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]) {
+        out = chalk[config.color](out);
+    }
+    if (config.bgColor && chalk[config.bgColor]) {
+        out = chalk[config.bgColor](out);
+    }
+    return out;
+}
+function calculateCwd(cwd, context) {
+    if (!cwd)
+        return context.root;
+    if ((0, path_1.isAbsolute)(cwd))
+        return cwd;
+    return (0, path_1.join)(context.root, cwd);
+}
+/**
+ * Env variables are processed in the following order:
+ * - env option from executor options
+ * - env file from envFile option if provided
+ * - local env variables
+ */
+function processEnv(color, cwd, envOptionFromExecutor, envFile) {
+    let localEnv = (0, npm_run_path_1.env)({ cwd: cwd ?? process.cwd() });
+    localEnv = {
+        ...process.env,
+        ...localEnv,
+    };
+    if (process.env.NX_LOAD_DOT_ENV_FILES !== 'false' && envFile) {
+        loadEnvVarsFile(envFile, localEnv);
+    }
+    let res = {
+        ...localEnv,
+        ...envOptionFromExecutor,
+    };
+    // need to override PATH to make sure we are using the local node_modules
+    if (localEnv.PATH)
+        res.PATH = localEnv.PATH; // UNIX-like
+    if (localEnv.Path)
+        res.Path = localEnv.Path; // Windows
+    if (color) {
+        res.FORCE_COLOR = `${color}`;
+    }
+    return res;
+}
+function isReady(readyWhenStatus = [], data) {
+    if (data) {
+        for (const readyWhenElement of readyWhenStatus) {
+            if (data.toString().indexOf(readyWhenElement.stringToMatch) > -1) {
+                readyWhenElement.found = true;
+                break;
+            }
+        }
+    }
+    return readyWhenStatus.every((readyWhenElement) => readyWhenElement.found);
+}
+function loadEnvVarsFile(path, env = {}) {
+    (0, task_env_1.unloadDotEnvFile)(path, env);
+    const result = (0, task_env_1.loadAndExpandDotEnvFile)(path, env);
+    if (result.error) {
+        throw result.error;
+    }
+}

package/src/native/index.d.ts

@@ -11,6 +11,7 @@ export declare class ChildProcess {
   kill(): void
   onExit(callback: (message: string) => void): void
   onOutput(callback: (message: string) => void): void
+  cleanup(): void
 }
 
 export declare class FileLock {

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/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/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/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/tasks-runner/create-task-graph.d.ts

@@ -11,6 +11,9 @@ export declare class ProcessTasks {
     readonly dependencies: {
         [k: string]: string[];
     };
+    readonly continuousDependencies: {
+        [k: string]: string[];
+    };
     private readonly allTargetNames;
     constructor(extraTargetDependencies: TargetDependencies, projectGraph: ProjectGraph);
     processTasks(projectNames: string[], targets: string[], configuration: string, overrides: Object, excludeTaskDependencies: boolean): string[];