nx 20.8.4 → 22.7.7

package/dist/src/project-graph/plugins/isolation/worker-streaming.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setPluginWorkerHostSocket = setPluginWorkerHostSocket;
+exports.emitPluginWorkerLog = emitPluginWorkerLog;
+const messaging_1 = require("./messaging");
+// Plugin workers talk to their host process over a single socket that
+// is established when the host connects. Plugin code running anywhere
+// in the worker process needs a way to emit log lines without having
+// that socket threaded through every call frame, so we stash a
+// module-level reference here when the host connects.
+let hostSocket = null;
+function setPluginWorkerHostSocket(socket) {
+    hostSocket = socket;
+    socket.once('close', () => {
+        if (hostSocket === socket)
+            hostSocket = null;
+    });
+}
+/**
+ * Emits a log line from the plugin worker up to its host. The host
+ * decides where it ends up (direct stdout/stderr when running under the
+ * CLI, forwarded to the active daemon client when running under the
+ * daemon).
+ *
+ * When plugin isolation is turned off, or this is otherwise called
+ * outside of a connected plugin worker, the message is written
+ * directly to stdout/stderr so the log line isn't silently dropped.
+ */
+function emitPluginWorkerLog(level, message) {
+    if (!hostSocket) {
+        console[level](message);
+        return;
+    }
+    (0, messaging_1.sendMessageOverSocket)(hostSocket, {
+        type: 'emitLog',
+        level,
+        message,
+    });
+}

package/dist/src/project-graph/plugins/load-resolved-plugin.d.ts

@@ -0,0 +1,3 @@
+import type { PluginConfiguration } from '../../config/nx-json';
+import { LoadedNxPlugin } from './loaded-nx-plugin';
+export declare function loadResolvedNxPluginAsync(pluginConfiguration: PluginConfiguration, pluginPath: string, name: string, index?: number): Promise<LoadedNxPlugin>;

package/dist/src/project-graph/plugins/load-resolved-plugin.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadResolvedNxPluginAsync = loadResolvedNxPluginAsync;
+const loaded_nx_plugin_1 = require("./loaded-nx-plugin");
+const handle_import_1 = require("../../utils/handle-import");
+async function loadResolvedNxPluginAsync(pluginConfiguration, pluginPath, name, index) {
+    // This needs to be spread to create an extensible object.
+    const plugin = { ...(await importPluginModule(pluginPath)) };
+    plugin.name ??= name;
+    return new loaded_nx_plugin_1.LoadedNxPlugin(plugin, pluginConfiguration, index);
+}
+async function importPluginModule(pluginPath) {
+    const m = await (0, handle_import_1.handleImport)(pluginPath);
+    if (m.default &&
+        ('createNodes' in m.default ||
+            'createNodesV2' in m.default ||
+            'createDependencies' in m.default ||
+            'createMetadata' in m.default ||
+            'preTasksExecution' in m.default ||
+            'postTasksExecution' in m.default)) {
+        return m.default;
+    }
+    return m;
+}

package/dist/src/project-graph/plugins/loaded-nx-plugin.d.ts

@@ -0,0 +1,41 @@
+import type { ProjectGraph } from '../../config/project-graph';
+import { type PluginConfiguration } from '../../config/nx-json';
+import type { RawProjectGraphDependency } from '../project-graph-builder';
+import type { CreateDependenciesContext, CreateMetadataContext, CreateNodesContextV2, CreateNodesResult, NxPluginV2, PostTasksExecutionContext, PreTasksExecutionContext, ProjectsMetadata } from './public-api';
+/**
+ * NOTE: Avoid using `import type` with this class. It causes issues with
+ * jest's module resolution when running tests in projects that import
+ * the devkit-internals
+ */
+export declare class LoadedNxPlugin {
+    readonly index?: number;
+    readonly name: string;
+    readonly createNodes?: [
+        filePattern: string,
+        fn: (matchedFiles: string[], context: CreateNodesContextV2) => Promise<Array<readonly [plugin: string, file: string, result: CreateNodesResult]>>
+    ];
+    readonly createDependencies?: (context: CreateDependenciesContext) => Promise<RawProjectGraphDependency[]>;
+    readonly createMetadata?: (graph: ProjectGraph, context: CreateMetadataContext) => Promise<ProjectsMetadata>;
+    readonly preTasksExecution?: (context: PreTasksExecutionContext) => Promise<NodeJS.ProcessEnv>;
+    readonly postTasksExecution?: (context: PostTasksExecutionContext) => Promise<void>;
+    readonly options?: unknown;
+    readonly include?: string[];
+    readonly exclude?: string[];
+    /**
+     * Notifies the plugin that a phase was aborted mid-flight.
+     * Overridden by IsolatedPlugin to reset lifecycle phase tracking so
+     * the worker can still shut down properly.
+     *
+     * @param phase The phase that was aborted (e.g. 'graph').
+     * @param lastCompletedHook The last hook that was called before the
+     *   abort (e.g. 'createNodes').
+     */
+    notifyPhaseAborted?(phase: string, lastCompletedHook: string): void;
+    /**
+     * Forwards updated environment variables to the plugin worker process.
+     * Only meaningful for isolated plugins; in-process plugins share the
+     * daemon's process.env automatically.
+     */
+    setWorkerEnv?(env: Record<string, string>): Promise<void>;
+    constructor(plugin: NxPluginV2, pluginDefinition: PluginConfiguration, index?: number);
+}

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

@@ -0,0 +1,101 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LoadedNxPlugin = void 0;
+const analytics_1 = require("../../analytics");
+const error_types_1 = require("../error-types");
+const enabled_1 = require("./isolation/enabled");
+const client_1 = require("../../daemon/client/client");
+/**
+ * NOTE: Avoid using `import type` with this class. It causes issues with
+ * jest's module resolution when running tests in projects that import
+ * the devkit-internals
+ */
+class LoadedNxPlugin {
+    constructor(plugin, pluginDefinition, index) {
+        this.index = index;
+        this.name = plugin.name;
+        if (typeof pluginDefinition !== 'string') {
+            this.options = pluginDefinition.options;
+            this.include = pluginDefinition.include;
+            this.exclude = pluginDefinition.exclude;
+        }
+        const createNodesV2Impl = plugin.createNodesV2 ?? plugin.createNodes;
+        if (createNodesV2Impl) {
+            this.createNodes = [
+                createNodesV2Impl[0],
+                async (configFiles, context) => {
+                    const result = await createNodesV2Impl[1](configFiles, this.options, context);
+                    return result.map((r) => [this.name, r[0], r[1]]);
+                },
+            ];
+        }
+        /**
+         * Wraps the plugin-provided createNodes function to provide performance
+         * measurement and error handling.
+         */
+        if (this.createNodes) {
+            const inner = this.createNodes[1];
+            this.createNodes[1] = async (...args) => {
+                performance.mark(`${plugin.name}:createNodes - start`);
+                let projectCount = 0;
+                try {
+                    const result = await inner(...args);
+                    for (const [, , r] of result) {
+                        projectCount += Object.keys(r.projects ?? {}).length;
+                    }
+                    return result;
+                }
+                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`, {
+                        start: `${plugin.name}:createNodes - start`,
+                        end: `${plugin.name}:createNodes - end`,
+                        detail: {
+                            track: true,
+                            ...(analytics_1.customDimensions && {
+                                [analytics_1.customDimensions.projectCount]: projectCount,
+                            }),
+                        },
+                    });
+                }
+            };
+        }
+        if (plugin.createDependencies) {
+            this.createDependencies = async (context) => plugin.createDependencies(this.options, context);
+        }
+        if (plugin.createMetadata) {
+            this.createMetadata = async (graph, context) => plugin.createMetadata(graph, this.options, context);
+        }
+        if (plugin.preTasksExecution) {
+            this.preTasksExecution = async (context) => {
+                const updates = {};
+                let originalEnv = process.env;
+                if ((0, enabled_1.isIsolationEnabled)() || (0, client_1.isDaemonEnabled)()) {
+                    process.env = new Proxy(originalEnv, {
+                        set: (target, key, value) => {
+                            target[key] = value;
+                            updates[key] = value;
+                            return true;
+                        },
+                    });
+                }
+                await plugin.preTasksExecution(this.options, context);
+                // This doesn't revert env changes, as the proxy still updates
+                // originalEnv, rather it removes the proxy.
+                process.env = originalEnv;
+                return updates;
+            };
+        }
+        if (plugin.postTasksExecution) {
+            this.postTasksExecution = async (context) => plugin.postTasksExecution(this.options, context);
+        }
+    }
+}
+exports.LoadedNxPlugin = LoadedNxPlugin;

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

@@ -0,0 +1,120 @@
+import type { FileMap, ProjectGraph, ProjectGraphExternalNode } from '../../config/project-graph';
+import type { ProjectConfiguration } from '../../config/workspace-json-project-json';
+import type { NxJsonConfiguration } from '../../config/nx-json';
+import type { RawProjectGraphDependency } from '../project-graph-builder';
+import type { TaskResults } from '../../tasks-runner/life-cycle';
+export interface CreateNodesContextV2 {
+    readonly nxJsonConfiguration: NxJsonConfiguration;
+    readonly workspaceRoot: string;
+}
+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 {
+    /**
+     * A map of project root -> project configuration
+     */
+    projects?: Record<string, Optional<ProjectConfiguration, 'root'>>;
+    /**
+     * A map of external node name -> external node. External nodes do not have a root, so the key is their name.
+     */
+    externalNodes?: Record<string, ProjectGraphExternalNode>;
+}
+/**
+ * A pair of file patterns and {@link CreateNodesFunctionV2}
+ * In Nx 21 {@link CreateNodes} will be replaced with this type. In Nx 22, this type will be removed.
+ */
+export type CreateNodesV2<T = unknown> = readonly [
+    projectFilePattern: string,
+    createNodesFunction: CreateNodesFunctionV2<T>
+];
+/**
+ * Context for {@link CreateDependencies}
+ */
+export interface CreateDependenciesContext {
+    /**
+     * The external nodes that have been added to the graph.
+     */
+    readonly externalNodes: ProjectGraph['externalNodes'];
+    /**
+     * The configuration of each project in the workspace keyed by project name.
+     */
+    readonly projects: Record<string, ProjectConfiguration>;
+    /**
+     * The `nx.json` configuration from the workspace
+     */
+    readonly nxJsonConfiguration: NxJsonConfiguration;
+    /**
+     * All files in the workspace
+     */
+    readonly fileMap: FileMap;
+    /**
+     * Files changes since last invocation
+     */
+    readonly filesToProcess: FileMap;
+    readonly workspaceRoot: string;
+}
+/**
+ * A function which parses files in the workspace to create dependencies in the {@link ProjectGraph}
+ * Use {@link validateDependency} to validate dependencies
+ */
+export type CreateDependencies<T = unknown> = (options: T | undefined, context: CreateDependenciesContext) => RawProjectGraphDependency[] | Promise<RawProjectGraphDependency[]>;
+export type CreateMetadataContext = {
+    readonly nxJsonConfiguration: NxJsonConfiguration;
+    readonly workspaceRoot: string;
+};
+export type ProjectsMetadata = Record<string, Pick<ProjectConfiguration, 'metadata'>>;
+export type CreateMetadata<T = unknown> = (graph: ProjectGraph, options: T | undefined, context: CreateMetadataContext) => ProjectsMetadata | Promise<ProjectsMetadata>;
+/**
+ * A plugin which enhances the behavior of Nx
+ */
+export type NxPluginV2<TOptions = unknown> = {
+    name: string;
+    /**
+     * Provides a file pattern and function that retrieves configuration info from
+     * those files. e.g. { '**\/*.csproj': buildProjectsFromCsProjFile }
+     */
+    createNodes?: CreateNodesV2<TOptions>;
+    /**
+     * Provides a file pattern and function that retrieves configuration info from
+     * those files. e.g. { '**\/*.csproj': buildProjectsFromCsProjFiles }
+     */
+    createNodesV2?: CreateNodesV2<TOptions>;
+    /**
+     * Provides a function to analyze files to create dependencies for the {@link ProjectGraph}
+     */
+    createDependencies?: CreateDependencies<TOptions>;
+    /**
+     * Provides a function to create metadata for the {@link ProjectGraph}
+     */
+    createMetadata?: CreateMetadata<TOptions>;
+    /**
+     * Provides a function to run before the Nx runs tasks
+     */
+    preTasksExecution?: PreTasksExecution<TOptions>;
+    /**
+     * Provides a function to run after the Nx runs tasks
+     */
+    postTasksExecution?: PostTasksExecution<TOptions>;
+};
+export type PreTasksExecutionContext = {
+    readonly id: string;
+    readonly workspaceRoot: string;
+    readonly nxJsonConfiguration: NxJsonConfiguration;
+    readonly argv: string[];
+};
+export type PostTasksExecutionContext = {
+    readonly id: string;
+    readonly workspaceRoot: string;
+    readonly nxJsonConfiguration: NxJsonConfiguration;
+    readonly taskResults: TaskResults;
+    readonly argv: string[];
+    readonly startTime: number;
+    readonly endTime: number;
+};
+export type PreTasksExecution<TOptions = unknown> = (options: TOptions | undefined, context: PreTasksExecutionContext) => void | Promise<void>;
+export type PostTasksExecution<TOptions = unknown> = (options: TOptions | undefined, context: PostTasksExecutionContext) => void | Promise<void>;
+/**
+ * A plugin which enhances the behavior of Nx
+ */
+export type NxPlugin<TOptions = unknown> = NxPluginV2<TOptions>;

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

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

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

@@ -0,0 +1,256 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveNxPlugin = resolveNxPlugin;
+exports.resolveLocalNxPlugin = resolveLocalNxPlugin;
+exports.getPluginPathAndName = getPluginPathAndName;
+const tslib_1 = require("tslib");
+const path = tslib_1.__importStar(require("node:path"));
+const node_fs_1 = require("node:fs");
+const resolve_exports_1 = require("resolve.exports");
+const packages_1 = require("../../plugins/js/utils/packages");
+const typescript_1 = require("../../plugins/js/utils/typescript");
+const fileutils_1 = require("../../utils/fileutils");
+const logger_1 = require("../../utils/logger");
+const path_1 = require("../../utils/path");
+const workspace_root_1 = require("../../utils/workspace-root");
+const find_project_for_path_1 = require("../utils/find-project-for-path");
+const retrieve_workspace_files_1 = require("../utils/retrieve-workspace-files");
+const TS_SOURCE_EXTENSIONS = new Set(['.ts', '.tsx', '.cts', '.mts']);
+let projectsWithoutInference;
+let projectsWithoutInferencePromise = null;
+async function resolveNxPlugin(moduleName, root, paths) {
+    // Default plugins (see `getDefaultPlugins` in `get-plugins.ts`) are passed
+    // as absolute file paths to compiled bundles inside `nx` itself; they are
+    // never workspace-local. Skip the project load entirely for them to avoid
+    // recursing through `retrieveProjectConfigurationsWithoutPluginInference`,
+    // which itself triggers default-plugin loading.
+    if (!path.isAbsolute(moduleName)) {
+        let resolvedFromNode;
+        try {
+            resolvedFromNode = require.resolve(moduleName, { paths });
+        }
+        catch { }
+        // Load projects if Node couldn't resolve (so the local fallback can run)
+        // OR if Node resolved to a workspace-internal path (a symlinked workspace
+        // package whose source-first lookup should win over the symlinked dist).
+        if (!resolvedFromNode ||
+            isWorkspaceLocalResolution(resolvedFromNode, root)) {
+            projectsWithoutInferencePromise ??=
+                (0, retrieve_workspace_files_1.retrieveProjectConfigurationsWithoutPluginInference)(root);
+            projectsWithoutInference ??= await projectsWithoutInferencePromise;
+        }
+    }
+    const { pluginPath, name, shouldRegisterTSTranspiler } = getPluginPathAndName(moduleName, paths, projectsWithoutInference, root);
+    return { pluginPath, name, shouldRegisterTSTranspiler };
+}
+/**
+ * Distinguishes a symlinked workspace package (where `require.resolve`
+ * follows the package-manager symlink into the workspace source tree) from
+ * a truly-installed dependency under `node_modules/`. The former needs the
+ * source-first lookup to bypass the dist that Node would otherwise return.
+ */
+function isWorkspaceLocalResolution(resolvedPath, root) {
+    const normalizedRoot = path.normalize(root);
+    const normalizedPath = path.normalize(resolvedPath);
+    return (normalizedPath.startsWith(normalizedRoot + path.sep) &&
+        !normalizedPath.includes(path.sep + 'node_modules' + path.sep));
+}
+function isPackageResolutionError(e) {
+    const code = e.code;
+    return (code === 'MODULE_NOT_FOUND' || code === 'ERR_PACKAGE_PATH_NOT_EXPORTED');
+}
+function readPluginMainFromProjectConfiguration(plugin) {
+    const { main } = Object.values(plugin.targets).find((x) => [
+        '@nx/js:tsc',
+        '@nrwl/js:tsc',
+        '@nx/js:swc',
+        '@nrwl/js:swc',
+        '@nx/node:package',
+        '@nrwl/node:package',
+    ].includes(x.executor))?.options ||
+        plugin.targets?.build?.options ||
+        {};
+    return main;
+}
+function resolveLocalNxPlugin(importPath, projects, root = workspace_root_1.workspaceRoot) {
+    return lookupLocalPlugin(importPath, projects, root);
+}
+function getPluginPathAndName(moduleName, paths, projects, root) {
+    let pluginPath;
+    // Resolve local workspace plugins from source first so the workspace's
+    // `customConditions`/`development` exports condition wins over the built
+    // `dist` artifact that Node's resolver would otherwise pick up via the
+    // `default` condition (Node ignores TypeScript custom conditions). Skipped
+    // when `projects` weren't loaded — the caller already determined that the
+    // import isn't a workspace package.
+    const localPlugin = projects
+        ? resolveLocalNxPlugin(moduleName, projects, root)
+        : null;
+    if (localPlugin) {
+        pluginPath = tryResolveLocalPluginFromSource(moduleName, localPlugin, root);
+        if (!pluginPath && getSubpathOfLocalPackage(moduleName, localPlugin)) {
+            throwUnresolvableLocalPluginError(moduleName, localPlugin, root);
+        }
+    }
+    if (!pluginPath) {
+        try {
+            pluginPath = require.resolve(moduleName, { paths });
+        }
+        catch (e) {
+            if (localPlugin && isPackageResolutionError(e)) {
+                throwUnresolvableLocalPluginError(moduleName, localPlugin, root);
+            }
+            if (e.code !== 'MODULE_NOT_FOUND') {
+                throw e;
+            }
+            if (localPlugin) {
+                throwUnresolvableLocalPluginError(moduleName, localPlugin, root);
+            }
+            logger_1.logger.error(`Plugin listed in \`nx.json\` not found: ${moduleName}`);
+            throw e;
+        }
+    }
+    const ext = path.extname(pluginPath);
+    // Directory paths fall through to Node's `package.json` `main` resolution
+    // which may land on a TS file; only opt out of TS transpiler registration
+    // when the resolved path is unambiguously JS.
+    const shouldRegisterTSTranspiler = ext === '' || TS_SOURCE_EXTENSIONS.has(ext);
+    const packageJsonPath = path.join(pluginPath, 'package.json');
+    const { name } = !['.ts', '.js'].some((x) => path.extname(moduleName) === x) && // Not trying to point to a ts or js file
+        (0, node_fs_1.existsSync)(packageJsonPath) // plugin has a package.json
+        ? (0, fileutils_1.readJsonFile)(packageJsonPath) // read name from package.json
+        : { name: moduleName };
+    return { pluginPath, name, shouldRegisterTSTranspiler };
+}
+function getSubpathOfLocalPackage(moduleName, plugin) {
+    const packageName = plugin.projectConfig.metadata?.js?.packageName;
+    if (!packageName || !moduleName.startsWith(packageName + '/')) {
+        return null;
+    }
+    return '.' + moduleName.slice(packageName.length);
+}
+function tryResolveLocalPluginFromSource(moduleName, plugin, root) {
+    if (plugin.resolvedFile) {
+        return plugin.resolvedFile;
+    }
+    const subpath = getSubpathOfLocalPackage(moduleName, plugin);
+    if (subpath) {
+        return resolveSubpathFromExports(plugin.projectConfig, plugin.path, subpath, root);
+    }
+    const main = readPluginMainFromProjectConfiguration(plugin.projectConfig);
+    return main ? path.join(root, main) : null;
+}
+function throwUnresolvableLocalPluginError(moduleName, plugin, root) {
+    const subpath = getSubpathOfLocalPackage(moduleName, plugin);
+    const packageName = plugin.projectConfig.metadata?.js?.packageName;
+    if (subpath) {
+        throw new Error(`Unable to resolve local plugin "${moduleName}". The import targets ` +
+            `the subpath "${subpath}" of the local package "${packageName}", but ` +
+            `the package's "exports" map has no resolvable entry for "${subpath}", ` +
+            `or none of the matched paths exist on disk. Check the "exports" field ` +
+            `in "${path.relative(root, path.join(plugin.path, 'package.json'))}" ` +
+            `and ensure the source file referenced by "${subpath}" exists.`);
+    }
+    throw new Error(`Unable to resolve local plugin "${moduleName}". The local package ` +
+        `"${packageName ?? moduleName}" does not declare a build target with ` +
+        `a "main" source path, and Node could not resolve it either.`);
+}
+function resolveSubpathFromExports(projectConfig, projectPath, subpath, root) {
+    const packageExports = projectConfig.metadata?.js?.packageExports;
+    if (!packageExports) {
+        return null;
+    }
+    const pkg = {
+        name: projectConfig.metadata.js.packageName,
+        exports: packageExports,
+    };
+    try {
+        const matches = (0, resolve_exports_1.resolve)(pkg, subpath, {
+            conditions: (0, typescript_1.getRootTsConfigResolveExportsConditions)(root),
+        });
+        if (!matches || !matches.length) {
+            return null;
+        }
+        for (const match of matches) {
+            const candidate = path.join(projectPath, match);
+            if ((0, node_fs_1.existsSync)(candidate)) {
+                return candidate;
+            }
+        }
+    }
+    catch (e) {
+        logger_1.logger.verbose(`Failed to resolve subpath "${subpath}" of local plugin via package.json exports`, e);
+    }
+    return null;
+}
+function lookupLocalPlugin(importPath, projects, root = workspace_root_1.workspaceRoot) {
+    const match = findNxProjectForImportPath(importPath, projects, root);
+    if (!match) {
+        return null;
+    }
+    let resolvedFile;
+    if (match.tsPathFile) {
+        const candidate = path.join(root, match.tsPathFile);
+        if (path.extname(candidate) && (0, node_fs_1.existsSync)(candidate)) {
+            resolvedFile = candidate;
+        }
+    }
+    return {
+        path: path.join(root, match.projectConfig.root),
+        projectConfig: match.projectConfig,
+        resolvedFile,
+    };
+}
+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)))) ?? [];
+    const projectRootMappings = new Map();
+    if (possibleTsPaths.length) {
+        const projectNameMap = new Map();
+        for (const projectRoot in projects) {
+            const project = projects[projectRoot];
+            projectRootMappings.set(project.root, project.name);
+            projectNameMap.set(project.name, project);
+        }
+        for (const tsConfigPath of possibleTsPaths) {
+            const nxProject = (0, find_project_for_path_1.findProjectForPath)(tsConfigPath, projectRootMappings);
+            if (nxProject) {
+                return {
+                    projectConfig: projectNameMap.get(nxProject),
+                    tsPathFile: tsConfigPath,
+                };
+            }
+        }
+    }
+    if (!packageEntryPointsToProjectMap && !wildcardEntryPointsToProjectMap) {
+        ({
+            entryPointsToProjectMap: packageEntryPointsToProjectMap,
+            wildcardEntryPointsToProjectMap,
+        } = (0, packages_1.getWorkspacePackagesMetadata)(projects));
+    }
+    if (packageEntryPointsToProjectMap[importPath]) {
+        return { projectConfig: packageEntryPointsToProjectMap[importPath] };
+    }
+    const project = (0, packages_1.matchImportToWildcardEntryPointsToProjectMap)(wildcardEntryPointsToProjectMap, importPath);
+    if (project) {
+        return { projectConfig: project };
+    }
+    logger_1.logger.verbose('Unable to find local plugin', possibleTsPaths, projectRootMappings);
+    return null;
+}
+let tsconfigPaths;
+function readTsConfigPaths(root = workspace_root_1.workspaceRoot) {
+    if (!tsconfigPaths) {
+        const tsconfigPath = ['tsconfig.base.json', 'tsconfig.json']
+            .map((x) => path.join(root, x))
+            .filter((x) => (0, node_fs_1.existsSync)(x))[0];
+        if (!tsconfigPath) {
+            throw new Error('unable to find tsconfig.base.json or tsconfig.json');
+        }
+        const { compilerOptions } = (0, fileutils_1.readJsonFile)(tsconfigPath);
+        tsconfigPaths = compilerOptions?.paths;
+    }
+    return tsconfigPaths ?? {};
+}

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

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

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

@@ -0,0 +1,4 @@
+import { CreateNodesContextV2, CreateNodesResult } from './public-api';
+export declare function createNodesFromFiles<T = unknown>(createNodes: (projectConfigurationFile: string, options: T | undefined, context: CreateNodesContextV2 & {
+    configFiles: readonly string[];
+}, idx: number) => CreateNodesResult | Promise<CreateNodesResult>, configFiles: readonly string[], options: T, context: CreateNodesContextV2): Promise<[file: string, value: CreateNodesResult][]>;