nx 19.2.0-canary.20240530-316dcb9 → 19.2.0-canary.20240601-6f22300

package/src/project-graph/plugins/internal-api.js

@@ -6,9 +6,10 @@ exports.getDefaultPlugins = exports.loadNxPlugins = exports.nxPluginCache = expo
 const path_1 = require("path");
 const workspace_root_1 = require("../../utils/workspace-root");
 const angular_json_1 = require("../../adapter/angular-json");
-const utils_1 = require("./utils");
 const isolation_1 = require("./isolation");
 const loader_1 = require("./loader");
+const utils_1 = require("./utils");
+const error_types_1 = require("../error-types");
 class LoadedNxPlugin {
     constructor(plugin, pluginDefinition) {
         this.name = plugin.name;
@@ -17,12 +18,41 @@ class LoadedNxPlugin {
             this.include = pluginDefinition.include;
             this.exclude = pluginDefinition.exclude;
         }
-        if (plugin.createNodes) {
+        if (plugin.createNodes && !plugin.createNodesV2) {
             this.createNodes = [
                 plugin.createNodes[0],
-                (files, context) => (0, utils_1.runCreateNodesInParallel)(files, plugin, this.options, context),
+                (configFiles, context) => (0, utils_1.createNodesFromFiles)(plugin.createNodes[1], configFiles, this.options, context).then((results) => results.map((r) => [this.name, r[0], r[1]])),
+            ];
+        }
+        if (plugin.createNodesV2) {
+            this.createNodes = [
+                plugin.createNodesV2[0],
+                async (configFiles, context) => {
+                    const result = await plugin.createNodesV2[1](configFiles, this.options, context);
+                    return result.map((r) => [this.name, r[0], r[1]]);
+                },
             ];
         }
+        if (this.createNodes) {
+            const inner = this.createNodes[1];
+            this.createNodes[1] = async (...args) => {
+                performance.mark(`${plugin.name}:createNodes - start`);
+                try {
+                    return await inner(...args);
+                }
+                catch (e) {
+                    if ((0, error_types_1.isAggregateCreateNodesError)(e)) {
+                        throw e;
+                    }
+                    // The underlying plugin errored out. We can't know any partial results.
+                    throw new error_types_1.AggregateCreateNodesError([null, e], []);
+                }
+                finally {
+                    performance.mark(`${plugin.name}:createNodes - end`);
+                    performance.measure(`${plugin.name}:createNodes`, `${plugin.name}:createNodes - start`, `${plugin.name}:createNodes - end`);
+                }
+            };
+        }
         if (plugin.createDependencies) {
             this.createDependencies = (context) => plugin.createDependencies(this.options, context);
         }

package/src/project-graph/plugins/isolation/plugin-pool.js

@@ -15,17 +15,18 @@ function loadRemoteNxPlugin(plugin, root) {
     // but its typescript.
     const isWorkerTypescript = path.extname(__filename) === '.ts';
     const workerPath = path.join(__dirname, 'plugin-worker');
+    const env = {
+        ...process.env,
+        ...(isWorkerTypescript
+            ? {
+                // Ensures that the worker uses the same tsconfig as the main process
+                TS_NODE_PROJECT: path.join(__dirname, '../../../../tsconfig.lib.json'),
+            }
+            : {}),
+    };
     const worker = (0, child_process_1.fork)(workerPath, [], {
         stdio: ['ignore', 'inherit', 'inherit', 'ipc'],
-        env: {
-            ...process.env,
-            ...(isWorkerTypescript
-                ? {
-                    // Ensures that the worker uses the same tsconfig as the main process
-                    TS_NODE_PROJECT: path.join(__dirname, '../../../tsconfig.lib.json'),
-                }
-                : {}),
-        },
+        env,
         execArgv: [
             ...process.execArgv,
             // If the worker is typescript, we need to register ts-node

package/src/project-graph/plugins/public-api.d.ts

@@ -6,19 +6,23 @@ import { RawProjectGraphDependency } from '../project-graph-builder';
 /**
  * Context for {@link CreateNodesFunction}
  */
-export interface CreateNodesContext {
-    readonly nxJsonConfiguration: NxJsonConfiguration;
-    readonly workspaceRoot: string;
+export interface CreateNodesContext extends CreateNodesContextV2 {
     /**
      * The subset of configuration files which match the createNodes pattern
      */
     readonly configFiles: readonly string[];
 }
+export interface CreateNodesContextV2 {
+    readonly nxJsonConfiguration: NxJsonConfiguration;
+    readonly workspaceRoot: string;
+}
 /**
  * A function which parses a configuration file into a set of nodes.
  * Used for creating nodes for the {@link ProjectGraph}
  */
 export type CreateNodesFunction<T = unknown> = (projectConfigurationFile: string, options: T | undefined, context: CreateNodesContext) => CreateNodesResult | Promise<CreateNodesResult>;
+export type CreateNodesResultV2 = Array<readonly [configFileSource: string, result: CreateNodesResult]>;
+export type CreateNodesFunctionV2<T = unknown> = (projectConfigurationFiles: readonly string[], options: T | undefined, context: CreateNodesContextV2) => CreateNodesResultV2 | Promise<CreateNodesResultV2>;
 export type Optional<T, K extends keyof T> = Omit<T, K> & Partial<Pick<T, K>>;
 export interface CreateNodesResult {
     /**
@@ -32,11 +36,29 @@ export interface CreateNodesResult {
 }
 /**
  * A pair of file patterns and {@link CreateNodesFunction}
+ *
+ * Nx 19.2+: Both original `CreateNodes` and `CreateNodesV2` are supported. Nx will only invoke `CreateNodesV2` if it is present.
+ * Nx 20.X : The `CreateNodesV2` will be the only supported API. This typing will still exist, but be identical to `CreateNodesV2`.
+             Nx **will not** invoke the original `plugin.createNodes` callback. This should give plugin authors a window to transition.
+             Plugin authors should update their plugin's `createNodes` function to align with `CreateNodesV2` / the updated `CreateNodes`.
+             The plugin should contain something like: `export createNodes = createNodesV2;` during this period. This will allow the plugin
+             to maintain compatibility with Nx 19.2 and up.
+ * Nx 21.X : The `CreateNodesV2` typing will be removed, as it has replaced `CreateNodes`.
+ *
+ * @deprecated Use {@link CreateNodesV2} instead. CreateNodesV2 will replace this API. Read more about the transition above.
  */
 export type CreateNodes<T = unknown> = readonly [
     projectFilePattern: string,
     createNodesFunction: CreateNodesFunction<T>
 ];
+/**
+ * A pair of file patterns and {@link CreateNodesFunctionV2}
+ * In Nx 20 {@link CreateNodes} will be replaced with this type. In Nx 21, this type will be removed.
+ */
+export type CreateNodesV2<T = unknown> = readonly [
+    projectFilePattern: string,
+    createNodesFunction: CreateNodesFunctionV2<T>
+];
 /**
  * Context for {@link CreateDependencies}
  */
@@ -82,8 +104,17 @@ export type NxPluginV2<TOptions = unknown> = {
     /**
      * Provides a file pattern and function that retrieves configuration info from
      * those files. e.g. { '**\/*.csproj': buildProjectsFromCsProjFile }
+     *
+     * @deprecated Use {@link createNodesV2} instead. In Nx 20 support for calling createNodes with a single file for the first argument will be removed.
      */
     createNodes?: CreateNodes<TOptions>;
+    /**
+     * Provides a file pattern and function that retrieves configuration info from
+     * those files. e.g. { '**\/*.csproj': buildProjectsFromCsProjFiles }
+     *
+     * In Nx 20 {@link createNodes} will be replaced with this property. In Nx 21, this property will be removed.
+     */
+    createNodesV2?: CreateNodesV2<TOptions>;
     /**
      * Provides a function to analyze files to create dependencies for the {@link ProjectGraph}
      */

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

@@ -1,7 +1,8 @@
 import type { NxPluginV1 } from '../../utils/nx-plugin.deprecated';
-import type { CreateNodesResultWithContext, LoadedNxPlugin, NormalizedPlugin } from './internal-api';
-import { type CreateNodesContext, type NxPlugin, type NxPluginV2 } from './public-api';
+import type { LoadedNxPlugin, NormalizedPlugin } from './internal-api';
+import { CreateNodesContextV2, CreateNodesFunction, CreateNodesResult, type NxPlugin, type NxPluginV2 } from './public-api';
 export declare function isNxPluginV2(plugin: NxPlugin): plugin is NxPluginV2;
 export declare function isNxPluginV1(plugin: NxPlugin | LoadedNxPlugin): plugin is NxPluginV1;
 export declare function normalizeNxPlugin(plugin: NxPlugin): NormalizedPlugin;
-export declare function runCreateNodesInParallel(configFiles: readonly string[], plugin: NormalizedPlugin, options: unknown, context: CreateNodesContext): Promise<CreateNodesResultWithContext[]>;
+export type AsyncFn<T extends Function> = T extends (...args: infer A) => infer R ? (...args: A) => Promise<Awaited<R>> : never;
+export declare function createNodesFromFiles<T = unknown>(createNodes: CreateNodesFunction<T>, configFiles: readonly string[], options: T, context: CreateNodesContextV2): Promise<[file: string, value: CreateNodesResult][]>;

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

@@ -1,11 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.runCreateNodesInParallel = exports.normalizeNxPlugin = exports.isNxPluginV1 = exports.isNxPluginV2 = void 0;
+exports.createNodesFromFiles = exports.normalizeNxPlugin = exports.isNxPluginV1 = exports.isNxPluginV2 = void 0;
 const node_path_1 = require("node:path");
 const to_project_name_1 = require("../../config/to-project-name");
 const globs_1 = require("../../utils/globs");
 const error_types_1 = require("../error-types");
-const perf_hooks_1 = require("perf_hooks");
 function isNxPluginV2(plugin) {
     return 'createNodes' in plugin || 'createDependencies' in plugin;
 }
@@ -40,36 +39,24 @@ function normalizeNxPlugin(plugin) {
     return plugin;
 }
 exports.normalizeNxPlugin = normalizeNxPlugin;
-async function runCreateNodesInParallel(configFiles, plugin, options, context) {
-    perf_hooks_1.performance.mark(`${plugin.name}:createNodes - start`);
-    const errors = [];
+async function createNodesFromFiles(createNodes, configFiles, options, context) {
     const results = [];
-    const promises = configFiles.map(async (file) => {
+    const errors = [];
+    await Promise.all(configFiles.map(async (file) => {
         try {
-            const value = await plugin.createNodes[1](file, options, context);
-            if (value) {
-                results.push({
-                    ...value,
-                    file,
-                    pluginName: plugin.name,
-                });
-            }
+            const value = await createNodes(file, options, {
+                ...context,
+                configFiles,
+            });
+            results.push([file, value]);
         }
         catch (e) {
-            errors.push(new error_types_1.CreateNodesError({
-                error: e,
-                pluginName: plugin.name,
-                file,
-            }));
+            errors.push([file, e]);
         }
-    });
-    await Promise.all(promises).then(() => {
-        perf_hooks_1.performance.mark(`${plugin.name}:createNodes - end`);
-        perf_hooks_1.performance.measure(`${plugin.name}:createNodes`, `${plugin.name}:createNodes - start`, `${plugin.name}:createNodes - end`);
-    });
+    }));
     if (errors.length > 0) {
-        throw new error_types_1.AggregateCreateNodesError(plugin.name, errors, results);
+        throw new error_types_1.AggregateCreateNodesError(errors, results);
     }
     return results;
 }
-exports.runCreateNodesInParallel = runCreateNodesInParallel;
+exports.createNodesFromFiles = createNodesFromFiles;

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

@@ -227,92 +227,35 @@ plugins) {
     const results = [];
     const errors = [];
     // We iterate over plugins first - this ensures that plugins specified first take precedence.
-    for (const { name: pluginName, createNodes: createNodesTuple, include, exclude, } of plugins) {
+    for (const { createNodes: createNodesTuple, include, exclude, name: pluginName, } of plugins) {
         const [pattern, createNodes] = createNodesTuple ?? [];
         if (!pattern) {
             continue;
         }
-        const matchingConfigFiles = [];
-        for (const file of projectFiles) {
-            if ((0, minimatch_1.minimatch)(file, pattern, { dot: true })) {
-                if (include) {
-                    const included = include.some((includedPattern) => (0, minimatch_1.minimatch)(file, includedPattern, { dot: true }));
-                    if (!included) {
-                        continue;
-                    }
-                }
-                if (exclude) {
-                    const excluded = exclude.some((excludedPattern) => (0, minimatch_1.minimatch)(file, excludedPattern, { dot: true }));
-                    if (excluded) {
-                        continue;
-                    }
-                }
-                matchingConfigFiles.push(file);
-            }
-        }
+        const matchingConfigFiles = findMatchingConfigFiles(projectFiles, pattern, include, exclude);
         let r = createNodes(matchingConfigFiles, {
             nxJsonConfiguration: nxJson,
             workspaceRoot: root,
-            configFiles: matchingConfigFiles,
         }).catch((e) => {
-            if ((0, error_types_1.isAggregateCreateNodesError)(e)) {
-                errors.push(...e.errors);
-                return e.partialResults;
-            }
-            else {
-                throw e;
-            }
+            const errorBodyLines = [
+                `An error occurred while processing files for the ${pluginName} plugin.`,
+            ];
+            const error = (0, error_types_1.isAggregateCreateNodesError)(e)
+                ? // This is an expected error if something goes wrong while processing files.
+                    e
+                : // This represents a single plugin erroring out with a hard error.
+                    new error_types_1.AggregateCreateNodesError([[null, e]], []);
+            errorBodyLines.push(...error.errors.map(([file, e]) => `  - ${file}: ${e.message}`));
+            error.message = errorBodyLines.join('\n');
+            // This represents a single plugin erroring out with a hard error.
+            errors.push(error);
+            // The plugin didn't return partial results, so we return an empty array.
+            return error.partialResults.map((r) => [pluginName, r[0], r[1]]);
         });
         results.push(r);
     }
     return Promise.all(results).then((results) => {
-        perf_hooks_1.performance.mark('createNodes:merge - start');
-        const projectRootMap = {};
-        const externalNodes = {};
-        const configurationSourceMaps = {};
-        for (const result of results.flat()) {
-            const { projects: projectNodes, externalNodes: pluginExternalNodes, file, pluginName, } = result;
-            const sourceInfo = [file, pluginName];
-            if (result[symbols_1.OVERRIDE_SOURCE_FILE]) {
-                sourceInfo[0] = result[symbols_1.OVERRIDE_SOURCE_FILE];
-            }
-            for (const node in projectNodes) {
-                // Handles `{projects: {'libs/foo': undefined}}`.
-                if (!projectNodes[node]) {
-                    continue;
-                }
-                const project = {
-                    root: node,
-                    ...projectNodes[node],
-                };
-                try {
-                    mergeProjectConfigurationIntoRootMap(projectRootMap, project, configurationSourceMaps, sourceInfo);
-                }
-                catch (error) {
-                    errors.push(new error_types_1.MergeNodesError({
-                        file,
-                        pluginName,
-                        error,
-                    }));
-                }
-            }
-            Object.assign(externalNodes, pluginExternalNodes);
-        }
-        try {
-            validateAndNormalizeProjectRootMap(projectRootMap);
-        }
-        catch (e) {
-            if ((0, error_types_1.isProjectsWithNoNameError)(e) ||
-                (0, error_types_1.isMultipleProjectsWithSameNameError)(e)) {
-                errors.push(e);
-            }
-            else {
-                throw e;
-            }
-        }
-        const rootMap = createRootMap(projectRootMap);
-        perf_hooks_1.performance.mark('createNodes:merge - end');
-        perf_hooks_1.performance.measure('createNodes:merge', 'createNodes:merge - start', 'createNodes:merge - end');
+        const { projectRootMap, externalNodes, rootMap, configurationSourceMaps } = mergeCreateNodesResults(results, errors);
         perf_hooks_1.performance.mark('build-project-configs:end');
         perf_hooks_1.performance.measure('build-project-configs', 'build-project-configs:start', 'build-project-configs:end');
         if (errors.length === 0) {
@@ -336,6 +279,78 @@ plugins) {
     });
 }
 exports.createProjectConfigurations = createProjectConfigurations;
+function mergeCreateNodesResults(results, errors) {
+    perf_hooks_1.performance.mark('createNodes:merge - start');
+    const projectRootMap = {};
+    const externalNodes = {};
+    const configurationSourceMaps = {};
+    for (const result of results.flat()) {
+        const [file, pluginName, nodes] = result;
+        const { projects: projectNodes, externalNodes: pluginExternalNodes } = nodes;
+        const sourceInfo = [file, pluginName];
+        if (result[symbols_1.OVERRIDE_SOURCE_FILE]) {
+            sourceInfo[0] = result[symbols_1.OVERRIDE_SOURCE_FILE];
+        }
+        for (const node in projectNodes) {
+            // Handles `{projects: {'libs/foo': undefined}}`.
+            if (!projectNodes[node]) {
+                continue;
+            }
+            const project = {
+                root: node,
+                ...projectNodes[node],
+            };
+            try {
+                mergeProjectConfigurationIntoRootMap(projectRootMap, project, configurationSourceMaps, sourceInfo);
+            }
+            catch (error) {
+                errors.push(new error_types_1.MergeNodesError({
+                    file,
+                    pluginName,
+                    error,
+                }));
+            }
+        }
+        Object.assign(externalNodes, pluginExternalNodes);
+    }
+    try {
+        validateAndNormalizeProjectRootMap(projectRootMap);
+    }
+    catch (e) {
+        if ((0, error_types_1.isProjectsWithNoNameError)(e) ||
+            (0, error_types_1.isMultipleProjectsWithSameNameError)(e)) {
+            errors.push(e);
+        }
+        else {
+            throw e;
+        }
+    }
+    const rootMap = createRootMap(projectRootMap);
+    perf_hooks_1.performance.mark('createNodes:merge - end');
+    perf_hooks_1.performance.measure('createNodes:merge', 'createNodes:merge - start', 'createNodes:merge - end');
+    return { projectRootMap, externalNodes, rootMap, configurationSourceMaps };
+}
+function findMatchingConfigFiles(projectFiles, pattern, include, exclude) {
+    const matchingConfigFiles = [];
+    for (const file of projectFiles) {
+        if ((0, minimatch_1.minimatch)(file, pattern, { dot: true })) {
+            if (include) {
+                const included = include.some((includedPattern) => (0, minimatch_1.minimatch)(file, includedPattern, { dot: true }));
+                if (!included) {
+                    continue;
+                }
+            }
+            if (exclude) {
+                const excluded = exclude.some((excludedPattern) => (0, minimatch_1.minimatch)(file, excludedPattern, { dot: true }));
+                if (excluded) {
+                    continue;
+                }
+            }
+            matchingConfigFiles.push(file);
+        }
+    }
+    return matchingConfigFiles;
+}
 function readProjectConfigurationsFromRootMap(projectRootMap) {
     const projects = {};
     // If there are projects that have the same name, that is an error.

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

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

package/src/project-graph/utils/retrieve-workspace-files.js

@@ -20,7 +20,7 @@ async function retrieveWorkspaceFiles(workspaceRoot, projectRootMap) {
     perf_hooks_1.performance.mark('native-file-deps:end');
     perf_hooks_1.performance.measure('native-file-deps', 'native-file-deps:start', 'native-file-deps:end');
     perf_hooks_1.performance.mark('get-workspace-files:start');
-    const { projectFileMap, globalFiles, externalReferences } = (0, workspace_context_1.getNxWorkspaceFilesFromContext)(workspaceRoot, projectRootMap);
+    const { projectFileMap, globalFiles, externalReferences } = await (0, workspace_context_1.getNxWorkspaceFilesFromContext)(workspaceRoot, projectRootMap);
     perf_hooks_1.performance.mark('get-workspace-files:end');
     perf_hooks_1.performance.measure('get-workspace-files', 'get-workspace-files:start', 'get-workspace-files:end');
     return {
@@ -36,9 +36,9 @@ exports.retrieveWorkspaceFiles = retrieveWorkspaceFiles;
 /**
  * Walk through the workspace and return `ProjectConfigurations`. Only use this if the projectFileMap is not needed.
  */
-function retrieveProjectConfigurations(plugins, workspaceRoot, nxJson) {
+async function retrieveProjectConfigurations(plugins, workspaceRoot, nxJson) {
     const globPatterns = configurationGlobs(plugins);
-    const workspaceFiles = (0, workspace_context_1.globWithWorkspaceContext)(workspaceRoot, globPatterns);
+    const workspaceFiles = await (0, workspace_context_1.globWithWorkspaceContext)(workspaceRoot, globPatterns);
     return (0, project_configuration_utils_1.createProjectConfigurations)(workspaceRoot, nxJson, workspaceFiles, plugins);
 }
 exports.retrieveProjectConfigurations = retrieveProjectConfigurations;
@@ -50,7 +50,7 @@ async function retrieveProjectConfigurationsWithAngularProjects(workspaceRoot, n
         pluginsToLoad.push((0, path_1.join)(__dirname, '../../adapter/angular-json'));
     }
     const [plugins, cleanup] = await (0, internal_api_1.loadNxPlugins)(nxJson?.plugins ?? [], workspaceRoot);
-    const res = retrieveProjectConfigurations(plugins, workspaceRoot, nxJson);
+    const res = await retrieveProjectConfigurations(plugins, workspaceRoot, nxJson);
     cleanup();
     return res;
 }
@@ -65,12 +65,12 @@ const projectsWithoutPluginCache = new Map();
 async function retrieveProjectConfigurationsWithoutPluginInference(root) {
     const nxJson = (0, nx_json_1.readNxJson)(root);
     const [plugins, cleanup] = await (0, internal_api_1.loadNxPlugins)([]); // only load default plugins
-    const projectGlobPatterns = retrieveProjectConfigurationPaths(root, plugins);
+    const projectGlobPatterns = await retrieveProjectConfigurationPaths(root, plugins);
     const cacheKey = root + ',' + projectGlobPatterns.join(',');
     if (projectsWithoutPluginCache.has(cacheKey)) {
         return projectsWithoutPluginCache.get(cacheKey);
     }
-    const projectFiles = (0, workspace_context_1.globWithWorkspaceContext)(root, projectGlobPatterns) ?? [];
+    const projectFiles = (await (0, workspace_context_1.globWithWorkspaceContext)(root, projectGlobPatterns)) ?? [];
     const { projects } = await (0, project_configuration_utils_1.createProjectConfigurations)(root, nxJson, projectFiles, plugins);
     projectsWithoutPluginCache.set(cacheKey, projects);
     cleanup();

package/src/utils/all-file-data.js

@@ -1,15 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.allFileData = void 0;
-const client_1 = require("../daemon/client/client");
 const workspace_context_1 = require("./workspace-context");
 const workspace_root_1 = require("./workspace-root");
 function allFileData() {
-    if (client_1.daemonClient.enabled()) {
-        return client_1.daemonClient.getAllFileData();
-    }
-    else {
-        return Promise.resolve((0, workspace_context_1.getAllFileDataInContext)(workspace_root_1.workspaceRoot));
-    }
+    return (0, workspace_context_1.getAllFileDataInContext)(workspace_root_1.workspaceRoot);
 }
 exports.allFileData = allFileData;

package/src/utils/workspace-context.d.ts

@@ -1,10 +1,18 @@
 import type { NxWorkspaceFilesExternals } from '../native';
 export declare function setupWorkspaceContext(workspaceRoot: string): void;
-export declare function getNxWorkspaceFilesFromContext(workspaceRoot: string, projectRootMap: Record<string, string>): import("../native").NxWorkspaceFiles;
-export declare function globWithWorkspaceContext(workspaceRoot: string, globs: string[], exclude?: string[]): string[];
-export declare function hashWithWorkspaceContext(workspaceRoot: string, globs: string[], exclude?: string[]): string;
+export declare function getNxWorkspaceFilesFromContext(workspaceRoot: string, projectRootMap: Record<string, string>): Promise<import("../native").NxWorkspaceFiles>;
+/**
+ * Sync method to get files matching globs from workspace context.
+ * NOTE: This method will create the workspace context if it doesn't exist.
+ * It should only be used within Nx internal in code paths that **must** be sync.
+ * If used in an isolated plugin thread this will cause the workspace context
+ * to be recreated which is slow.
+ */
+export declare function globWithWorkspaceContextSync(workspaceRoot: string, globs: string[], exclude?: string[]): string[];
+export declare function globWithWorkspaceContext(workspaceRoot: string, globs: string[], exclude?: string[]): Promise<string[]>;
+export declare function hashWithWorkspaceContext(workspaceRoot: string, globs: string[], exclude?: string[]): Promise<string>;
 export declare function updateFilesInContext(updatedFiles: string[], deletedFiles: string[]): Record<string, string>;
-export declare function getAllFileDataInContext(workspaceRoot: string): import("../native").FileData[];
-export declare function getFilesInDirectoryUsingContext(workspaceRoot: string, dir: string): string[];
+export declare function getAllFileDataInContext(workspaceRoot: string): Promise<import("../native").FileData[]>;
+export declare function getFilesInDirectoryUsingContext(workspaceRoot: string, dir: string): Promise<string[]>;
 export declare function updateProjectFiles(projectRootMappings: Record<string, string>, rustReferences: NxWorkspaceFilesExternals, updatedFiles: Record<string, string>, deletedFiles: string[]): import("../native").UpdatedWorkspaceFiles;
 export declare function resetWorkspaceContext(): void;

package/src/utils/workspace-context.js

@@ -1,8 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.resetWorkspaceContext = exports.updateProjectFiles = exports.getFilesInDirectoryUsingContext = exports.getAllFileDataInContext = exports.updateFilesInContext = exports.hashWithWorkspaceContext = exports.globWithWorkspaceContext = exports.getNxWorkspaceFilesFromContext = exports.setupWorkspaceContext = void 0;
+exports.resetWorkspaceContext = exports.updateProjectFiles = exports.getFilesInDirectoryUsingContext = exports.getAllFileDataInContext = exports.updateFilesInContext = exports.hashWithWorkspaceContext = exports.globWithWorkspaceContext = exports.globWithWorkspaceContextSync = exports.getNxWorkspaceFilesFromContext = exports.setupWorkspaceContext = void 0;
 const perf_hooks_1 = require("perf_hooks");
 const cache_directory_1 = require("./cache-directory");
+const is_on_daemon_1 = require("../daemon/is-on-daemon");
+const client_1 = require("../daemon/client/client");
 let workspaceContext;
 function setupWorkspaceContext(workspaceRoot) {
     const { WorkspaceContext } = require('../native');
@@ -12,33 +14,62 @@ function setupWorkspaceContext(workspaceRoot) {
     perf_hooks_1.performance.measure('workspace context init', 'workspace-context', 'workspace-context:end');
 }
 exports.setupWorkspaceContext = setupWorkspaceContext;
-function getNxWorkspaceFilesFromContext(workspaceRoot, projectRootMap) {
-    ensureContextAvailable(workspaceRoot);
-    return workspaceContext.getWorkspaceFiles(projectRootMap);
+async function getNxWorkspaceFilesFromContext(workspaceRoot, projectRootMap) {
+    if ((0, is_on_daemon_1.isOnDaemon)() || !client_1.daemonClient.enabled()) {
+        ensureContextAvailable(workspaceRoot);
+        return workspaceContext.getWorkspaceFiles(projectRootMap);
+    }
+    return client_1.daemonClient.getWorkspaceFiles(projectRootMap);
 }
 exports.getNxWorkspaceFilesFromContext = getNxWorkspaceFilesFromContext;
-function globWithWorkspaceContext(workspaceRoot, globs, exclude) {
+/**
+ * Sync method to get files matching globs from workspace context.
+ * NOTE: This method will create the workspace context if it doesn't exist.
+ * It should only be used within Nx internal in code paths that **must** be sync.
+ * If used in an isolated plugin thread this will cause the workspace context
+ * to be recreated which is slow.
+ */
+function globWithWorkspaceContextSync(workspaceRoot, globs, exclude) {
     ensureContextAvailable(workspaceRoot);
     return workspaceContext.glob(globs, exclude);
 }
+exports.globWithWorkspaceContextSync = globWithWorkspaceContextSync;
+async function globWithWorkspaceContext(workspaceRoot, globs, exclude) {
+    if ((0, is_on_daemon_1.isOnDaemon)() || !client_1.daemonClient.enabled()) {
+        ensureContextAvailable(workspaceRoot);
+        return workspaceContext.glob(globs, exclude);
+    }
+    else {
+        return client_1.daemonClient.glob(globs, exclude);
+    }
+}
 exports.globWithWorkspaceContext = globWithWorkspaceContext;
-function hashWithWorkspaceContext(workspaceRoot, globs, exclude) {
-    ensureContextAvailable(workspaceRoot);
-    return workspaceContext.hashFilesMatchingGlob(globs, exclude);
+async function hashWithWorkspaceContext(workspaceRoot, globs, exclude) {
+    if ((0, is_on_daemon_1.isOnDaemon)() || !client_1.daemonClient.enabled()) {
+        ensureContextAvailable(workspaceRoot);
+        return workspaceContext.hashFilesMatchingGlob(globs, exclude);
+    }
+    return client_1.daemonClient.hashGlob(globs, exclude);
 }
 exports.hashWithWorkspaceContext = hashWithWorkspaceContext;
 function updateFilesInContext(updatedFiles, deletedFiles) {
     return workspaceContext?.incrementalUpdate(updatedFiles, deletedFiles);
 }
 exports.updateFilesInContext = updateFilesInContext;
-function getAllFileDataInContext(workspaceRoot) {
-    ensureContextAvailable(workspaceRoot);
-    return workspaceContext.allFileData();
+async function getAllFileDataInContext(workspaceRoot) {
+    if ((0, is_on_daemon_1.isOnDaemon)() || !client_1.daemonClient.enabled()) {
+        ensureContextAvailable(workspaceRoot);
+        return workspaceContext.allFileData();
+    }
+    return client_1.daemonClient.getWorkspaceContextFileData();
 }
 exports.getAllFileDataInContext = getAllFileDataInContext;
-function getFilesInDirectoryUsingContext(workspaceRoot, dir) {
-    ensureContextAvailable(workspaceRoot);
-    return workspaceContext.getFilesInDirectory(dir);
+async function getFilesInDirectoryUsingContext(workspaceRoot, dir) {
+    if ((0, is_on_daemon_1.isOnDaemon)() || !client_1.daemonClient.enabled()) {
+        ensureContextAvailable(workspaceRoot);
+        return workspaceContext.getFilesInDirectory(dir);
+    }
+    return client_1.daemonClient.getFilesInDirectory(dir);
 }
 exports.getFilesInDirectoryUsingContext = getFilesInDirectoryUsingContext;
 function updateProjectFiles(projectRootMappings, rustReferences, updatedFiles, deletedFiles) {

package/src/daemon/server/handle-request-file-data.d.ts

@@ -1,4 +0,0 @@
-export declare function handleRequestFileData(): Promise<{
-    response: string;
-    description: string;
-}>;

package/src/daemon/server/handle-request-file-data.js

@@ -1,13 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.handleRequestFileData = void 0;
-const workspace_context_1 = require("../../utils/workspace-context");
-const workspace_root_1 = require("../../utils/workspace-root");
-async function handleRequestFileData() {
-    const response = JSON.stringify((0, workspace_context_1.getAllFileDataInContext)(workspace_root_1.workspaceRoot));
-    return {
-        response,
-        description: 'handleRequestFileData',
-    };
-}
-exports.handleRequestFileData = handleRequestFileData;