nx 19.0.0-canary.20240423-b37bfdb → 19.0.0-canary.20240426-ac9ad35

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

@@ -114,6 +114,17 @@ function createWorkerHandler(worker, pending, onload, onloadError) {
                                 });
                             }
                             : undefined,
+                        createMetadata: result.hasCreateMetadata
+                            ? (graph, ctx) => {
+                                const tx = pluginName + ':createMetadata:' + performance.now();
+                                return registerPendingPromise(tx, pending, () => {
+                                    worker.send({
+                                        type: 'createMetadata',
+                                        payload: { graph, context: ctx, tx },
+                                    });
+                                });
+                            }
+                            : undefined,
                     });
                 }
                 else if (result.success === false) {
@@ -147,6 +158,15 @@ function createWorkerHandler(worker, pending, onload, onloadError) {
                     rejector(result.error);
                 }
             },
+            createMetadataResult: ({ tx, ...result }) => {
+                const { resolver, rejector } = pending.get(tx);
+                if (result.success) {
+                    resolver(result.metadata);
+                }
+                else if (result.success === false) {
+                    rejector(result.error);
+                }
+            },
         });
     };
 }

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

@@ -3,6 +3,9 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const messaging_1 = require("./messaging");
 const loader_1 = require("../loader");
 const serializable_error_1 = require("../../../utils/serializable-error");
+if (process.env.NX_PERF_LOGGING === 'true') {
+    require('../../../utils/perf-logging');
+}
 global.NX_GRAPH_CREATION = true;
 let plugin;
 process.on('message', async (message) => {
@@ -22,6 +25,7 @@ process.on('message', async (message) => {
                         createNodesPattern: plugin.createNodes?.[0],
                         hasCreateDependencies: 'createDependencies' in plugin && !!plugin.createDependencies,
                         hasProcessProjectGraph: 'processProjectGraph' in plugin && !!plugin.processProjectGraph,
+                        hasCreateMetadata: 'createMetadata' in plugin && !!plugin.createMetadata,
                         success: true,
                     },
                 };
@@ -93,5 +97,20 @@ process.on('message', async (message) => {
                 };
             }
         },
+        createMetadata: async ({ graph, context, tx }) => {
+            try {
+                const result = await plugin.createMetadata(graph, context);
+                return {
+                    type: 'createMetadataResult',
+                    payload: { metadata: result, success: true, tx },
+                };
+            }
+            catch (e) {
+                return {
+                    type: 'createMetadataResult',
+                    payload: { success: false, error: e.stack, tx },
+                };
+            }
+        },
     });
 });

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

@@ -32,6 +32,9 @@ function readPluginPackageJson(pluginName, projects, paths = (0, installation_di
             const localPluginPath = resolveLocalNxPlugin(pluginName, projects);
             if (localPluginPath) {
                 const localPluginPackageJson = path.join(localPluginPath.path, 'package.json');
+                if (!exports.unregisterPluginTSTranspiler) {
+                    registerPluginTSTranspiler();
+                }
                 return {
                     path: localPluginPackageJson,
                     json: (0, fileutils_1.readJsonFile)(localPluginPackageJson),
@@ -77,22 +80,27 @@ function registerPluginTSTranspiler() {
 }
 exports.registerPluginTSTranspiler = registerPluginTSTranspiler;
 function lookupLocalPlugin(importPath, projects, root = workspace_root_1.workspaceRoot) {
-    const plugin = findNxProjectForImportPath(importPath, projects, root);
-    if (!plugin) {
+    const projectConfig = findNxProjectForImportPath(importPath, projects, root);
+    if (!projectConfig) {
         return null;
     }
-    const projectConfig = projects[plugin];
     return { path: path.join(root, projectConfig.root), projectConfig };
 }
 function findNxProjectForImportPath(importPath, projects, root = workspace_root_1.workspaceRoot) {
     const tsConfigPaths = readTsConfigPaths(root);
     const possiblePaths = tsConfigPaths[importPath]?.map((p) => (0, path_1.normalizePath)(path.relative(root, path.join(root, p))));
     if (possiblePaths?.length) {
-        const projectRootMappings = (0, find_project_for_path_1.createProjectRootMappingsFromProjectConfigurations)(projects);
+        const projectRootMappings = new Map();
+        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 possiblePaths) {
             const nxProject = (0, find_project_for_path_1.findProjectForPath)(tsConfigPath, projectRootMappings);
             if (nxProject) {
-                return nxProject;
+                return projectNameMap.get(nxProject);
             }
         }
         logger_1.logger.verbose('Unable to find local plugin', possiblePaths, projectRootMappings);

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

@@ -12,7 +12,7 @@ export interface CreateNodesContext {
     /**
      * The subset of configuration files which match the createNodes pattern
      */
-    readonly configFiles: string[];
+    readonly configFiles: readonly string[];
 }
 /**
  * A function which parses a configuration file into a set of nodes.
@@ -68,6 +68,12 @@ export interface CreateDependenciesContext {
  * 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 for Nx which creates nodes and dependencies for the {@link ProjectGraph}
  */
@@ -82,6 +88,10 @@ export type NxPluginV2<TOptions = unknown> = {
      * 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>;
 };
 /**
  * A plugin for Nx

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

@@ -1,7 +1,7 @@
 import type { NxPluginV1 } from '../../utils/nx-plugin.deprecated';
 import type { CreateNodesResultWithContext, LoadedNxPlugin, NormalizedPlugin } from './internal-api';
-import type { CreateNodesContext, NxPlugin, NxPluginV2 } from './public-api';
+import { type CreateNodesContext, 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: string[], plugin: NormalizedPlugin, options: unknown, context: CreateNodesContext): Promise<CreateNodesResultWithContext[]>;
+export declare function runCreateNodesInParallel(configFiles: readonly string[], plugin: NormalizedPlugin, options: unknown, context: CreateNodesContext): Promise<CreateNodesResultWithContext[]>;

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

@@ -43,30 +43,29 @@ async function runCreateNodesInParallel(configFiles, plugin, options, context) {
     performance.mark(`${plugin.name}:createNodes - start`);
     const errors = [];
     const results = [];
-    const promises = configFiles.map((file) => {
+    const promises = configFiles.map(async (file) => {
         performance.mark(`${plugin.name}:createNodes:${file} - start`);
-        // Result is either static or a promise, using Promise.resolve lets us
-        // handle both cases with same logic
-        const value = Promise.resolve(plugin.createNodes[1](file, options, context));
-        return value
-            .catch((e) => {
-            performance.mark(`${plugin.name}:createNodes:${file} - end`);
+        try {
+            const value = await plugin.createNodes[1](file, options, context);
+            if (value) {
+                results.push({
+                    ...value,
+                    file,
+                    pluginName: plugin.name,
+                });
+            }
+        }
+        catch (e) {
             errors.push(new error_types_1.CreateNodesError({
                 error: e,
                 pluginName: plugin.name,
                 file,
             }));
-            return null;
-        })
-            .then((r) => {
+        }
+        finally {
             performance.mark(`${plugin.name}:createNodes:${file} - end`);
             performance.measure(`${plugin.name}:createNodes:${file}`, `${plugin.name}:createNodes:${file} - start`, `${plugin.name}:createNodes:${file} - end`);
-            // Existing behavior is to ignore null results of
-            // createNodes function.
-            if (r) {
-                results.push({ ...r, file, pluginName: plugin.name });
-            }
-        });
+        }
     });
     await Promise.all(promises).then(() => {
         performance.mark(`${plugin.name}:createNodes - end`);

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

@@ -10,8 +10,8 @@ const output_1 = require("../utils/output");
 const strip_indents_1 = require("../utils/strip-indents");
 const workspace_root_1 = require("../utils/workspace-root");
 const build_project_graph_1 = require("./build-project-graph");
-const nx_deps_cache_1 = require("./nx-deps-cache");
 const error_types_1 = require("./error-types");
+const nx_deps_cache_1 = require("./nx-deps-cache");
 const internal_api_1 = require("./plugins/internal-api");
 const retrieve_workspace_files_1 = require("./utils/retrieve-workspace-files");
 /**
@@ -92,18 +92,18 @@ async function buildProjectGraphAndSourceMapsWithoutDaemon() {
     perf_hooks_1.performance.mark('retrieve-workspace-files:end');
     const cacheEnabled = process.env.NX_CACHE_PROJECT_GRAPH !== 'false';
     perf_hooks_1.performance.mark('build-project-graph-using-project-file-map:start');
-    let createDependenciesError;
+    let projectGraphError;
     let projectGraphResult;
     try {
-        projectGraphResult = await (0, build_project_graph_1.buildProjectGraphUsingProjectFileMap)(projects, externalNodes, fileMap, allWorkspaceFiles, rustReferences, cacheEnabled ? (0, nx_deps_cache_1.readFileMapCache)() : null, plugins);
+        projectGraphResult = await (0, build_project_graph_1.buildProjectGraphUsingProjectFileMap)(projects, externalNodes, fileMap, allWorkspaceFiles, rustReferences, cacheEnabled ? (0, nx_deps_cache_1.readFileMapCache)() : null, plugins, sourceMaps);
     }
     catch (e) {
-        if (e instanceof build_project_graph_1.CreateDependenciesError) {
+        if ((0, error_types_1.isAggregateProjectGraphError)(e)) {
             projectGraphResult = {
                 projectGraph: e.partialProjectGraph,
                 projectFileMapCache: null,
             };
-            createDependenciesError = e;
+            projectGraphError = e;
         }
         else {
             throw e;
@@ -117,7 +117,7 @@ async function buildProjectGraphAndSourceMapsWithoutDaemon() {
     delete global.NX_GRAPH_CREATION;
     const errors = [
         ...(projectConfigurationsError?.errors ?? []),
-        ...(createDependenciesError?.errors ?? []),
+        ...(projectGraphError?.errors ?? []),
     ];
     if (errors.length > 0) {
         throw new error_types_1.ProjectGraphError(errors, projectGraph, sourceMaps);

package/src/project-graph/utils/find-project-for-path.js

@@ -9,9 +9,8 @@ const path_2 = require("../../utils/path");
  */
 function createProjectRootMappingsFromProjectConfigurations(projects) {
     const projectRootMappings = new Map();
-    for (const projectName of Object.keys(projects)) {
-        const root = projects[projectName].root;
-        projectRootMappings.set(normalizeProjectRoot(root), projectName);
+    for (const { name, root } of Object.values(projects)) {
+        projectRootMappings.set(normalizeProjectRoot(root), name);
     }
     return projectRootMappings;
 }

package/src/project-graph/utils/normalize-project-nodes.d.ts

@@ -2,7 +2,7 @@ import { ProjectGraphProjectNode } from '../../config/project-graph';
 import { ProjectGraphBuilder } from '../project-graph-builder';
 import { ProjectConfiguration, TargetConfiguration } from '../../config/workspace-json-project-json';
 import { CreateDependenciesContext } from '../plugins';
-export declare function normalizeProjectNodes(ctx: CreateDependenciesContext, builder: ProjectGraphBuilder): Promise<void>;
+export declare function normalizeProjectNodes({ projects }: CreateDependenciesContext, builder: ProjectGraphBuilder): Promise<void>;
 /**
  * Apply target defaults and normalization
  */

package/src/project-graph/utils/normalize-project-nodes.js

@@ -3,15 +3,14 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.normalizeImplicitDependencies = exports.normalizeProjectTargets = exports.normalizeProjectNodes = void 0;
 const find_matching_projects_1 = require("../../utils/find-matching-projects");
 const project_configuration_utils_1 = require("../utils/project-configuration-utils");
-async function normalizeProjectNodes(ctx, builder) {
-    const toAdd = [];
+async function normalizeProjectNodes({ projects }, builder) {
     // Sorting projects by name to make sure that the order of projects in the graph is deterministic.
     // This is important to ensure that expanded properties referencing projects (e.g. implicit dependencies)
     // are also deterministic, and thus don't cause the calculated project configuration hash to shift.
-    const projects = Object.keys(ctx.projects).sort();
+    const sortedProjectNames = Object.keys(projects).sort();
     // Used for expanding implicit dependencies (e.g. `@proj/*` or `tag:foo`)
-    const partialProjectGraphNodes = projects.reduce((graph, project) => {
-        const projectConfiguration = ctx.projects[project];
+    const partialProjectGraphNodes = sortedProjectNames.reduce((graph, project) => {
+        const projectConfiguration = projects[project];
         graph[project] = {
             name: project,
             type: projectConfiguration.projectType === 'library' ? 'lib' : 'app', // missing fallback to `e2e`
@@ -21,8 +20,9 @@ async function normalizeProjectNodes(ctx, builder) {
         };
         return graph;
     }, {});
-    for (const key of projects) {
-        const p = ctx.projects[key];
+    const toAdd = [];
+    for (const key of sortedProjectNames) {
+        const p = projects[key];
         p.implicitDependencies = normalizeImplicitDependencies(key, p.implicitDependencies, partialProjectGraphNodes);
         p.targets = normalizeProjectTargets(p, key);
         // TODO: remove in v16
@@ -31,7 +31,7 @@ async function normalizeProjectNodes(ctx, builder) {
                 ? 'e2e'
                 : 'app'
             : 'lib';
-        const tags = ctx.projects?.[key]?.tags || [];
+        const tags = p.tags || [];
         toAdd.push({
             name: key,
             type: projectType,

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

@@ -1,20 +1,36 @@
 import { NxJsonConfiguration, TargetDefaults } from '../../config/nx-json';
 import { ProjectGraphExternalNode } from '../../config/project-graph';
-import { ProjectConfiguration, TargetConfiguration } from '../../config/workspace-json-project-json';
+import { ProjectConfiguration, ProjectMetadata, TargetConfiguration, TargetMetadata } from '../../config/workspace-json-project-json';
 import { ONLY_MODIFIES_EXISTING_TARGET } from '../../plugins/target-defaults/symbols';
 import { LoadedNxPlugin } from '../plugins/internal-api';
-export type SourceInformation = [file: string, plugin: string];
+export type SourceInformation = [file: string | null, plugin: string];
 export type ConfigurationSourceMaps = Record<string, Record<string, SourceInformation>>;
-export declare function mergeProjectConfigurationIntoRootMap(projectRootMap: Map<string, ProjectConfiguration>, project: ProjectConfiguration & {
+export declare function mergeProjectConfigurationIntoRootMap(projectRootMap: Record<string, ProjectConfiguration>, project: ProjectConfiguration & {
     targets?: Record<string, TargetConfiguration & {
         [ONLY_MODIFIES_EXISTING_TARGET]?: boolean;
     }>;
 }, configurationSourceMaps?: ConfigurationSourceMaps, sourceInformation?: SourceInformation, skipCommandNormalization?: boolean): void;
+export declare function mergeMetadata<T = ProjectMetadata | TargetMetadata>(sourceMap: Record<string, [file: string, plugin: string]>, sourceInformation: [file: string, plugin: string], baseSourceMapPath: string, metadata: T, matchingMetadata?: T): T;
 export type ConfigurationResult = {
-    projects: Record<string, ProjectConfiguration>;
+    /**
+     * A map of project configurations, keyed by project root.
+     */
+    projects: {
+        [projectRoot: string]: ProjectConfiguration;
+    };
+    /**
+     * Node Name -> Node info
+     */
     externalNodes: Record<string, ProjectGraphExternalNode>;
+    /**
+     * Project Root -> Project Name
+     */
     projectRootMap: Record<string, string>;
     sourceMaps: ConfigurationSourceMaps;
+    /**
+     * The list of files that were used to create project configurations
+     */
+    matchingProjectFiles: string[];
 };
 /**
  * Transforms a list of project paths into a map of project configurations.
@@ -26,7 +42,7 @@ export type ConfigurationResult = {
  */
 export declare function createProjectConfigurations(root: string, nxJson: NxJsonConfiguration, projectFiles: string[], // making this parameter allows devkit to pick up newly created projects
 plugins: LoadedNxPlugin[]): Promise<ConfigurationResult>;
-export declare function readProjectConfigurationsFromRootMap(projectRootMap: Map<string, ProjectConfiguration>): Record<string, ProjectConfiguration>;
+export declare function readProjectConfigurationsFromRootMap(projectRootMap: Record<string, ProjectConfiguration>): Record<string, ProjectConfiguration>;
 /**
  * Merges two targets.
  *

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

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.readTargetDefaultsForTarget = exports.resolveNxTokensInOptions = exports.isCompatibleTarget = exports.mergeTargetConfigurations = exports.readProjectConfigurationsFromRootMap = exports.createProjectConfigurations = exports.mergeProjectConfigurationIntoRootMap = void 0;
+exports.readTargetDefaultsForTarget = exports.resolveNxTokensInOptions = exports.isCompatibleTarget = exports.mergeTargetConfigurations = exports.readProjectConfigurationsFromRootMap = exports.createProjectConfigurations = exports.mergeMetadata = exports.mergeProjectConfigurationIntoRootMap = void 0;
 const logger_1 = require("../../utils/logger");
 const fileutils_1 = require("../../utils/fileutils");
 const workspace_root_1 = require("../../utils/workspace-root");
@@ -17,12 +17,12 @@ skipCommandNormalization) {
         configurationSourceMaps[project.root] = {};
     }
     const sourceMap = configurationSourceMaps?.[project.root];
-    let matchingProject = projectRootMap.get(project.root);
+    let matchingProject = projectRootMap[project.root];
     if (!matchingProject) {
-        projectRootMap.set(project.root, {
+        projectRootMap[project.root] = {
             root: project.root,
-        });
-        matchingProject = projectRootMap.get(project.root);
+        };
+        matchingProject = projectRootMap[project.root];
         if (sourceMap) {
             sourceMap[`root`] = sourceInformation;
         }
@@ -138,7 +138,8 @@ skipCommandNormalization) {
             updatedProjectConfiguration.targets[targetName] = mergedTarget;
         }
     }
-    projectRootMap.set(updatedProjectConfiguration.root, updatedProjectConfiguration);
+    projectRootMap[updatedProjectConfiguration.root] =
+        updatedProjectConfiguration;
 }
 exports.mergeProjectConfigurationIntoRootMap = mergeProjectConfigurationIntoRootMap;
 function mergeMetadata(sourceMap, sourceInformation, baseSourceMapPath, metadata, matchingMetadata) {
@@ -210,6 +211,7 @@ function mergeMetadata(sourceMap, sourceInformation, baseSourceMapPath, metadata
     }
     return result;
 }
+exports.mergeMetadata = mergeMetadata;
 /**
  * Transforms a list of project paths into a map of project configurations.
  *
@@ -264,7 +266,7 @@ plugins) {
     }
     return Promise.all(results).then((results) => {
         perf_hooks_1.performance.mark('createNodes:merge - start');
-        const projectRootMap = new Map();
+        const projectRootMap = {};
         const externalNodes = {};
         const configurationSourceMaps = {};
         for (const result of results.flat()) {
@@ -291,14 +293,17 @@ plugins) {
             }
             Object.assign(externalNodes, pluginExternalNodes);
         }
-        let projects;
         try {
-            projects = readProjectConfigurationsFromRootMap(projectRootMap);
+            // We still call this just to assert that the root map
+            // only contains valid project names. This is a safety check.
+            //
+            // The signature itself can't be changed as we need it to return
+            // project configurations for use in devkit.
+            readProjectConfigurationsFromRootMap(projectRootMap);
         }
         catch (e) {
             if ((0, error_types_1.isProjectsWithNoNameError)(e) ||
                 (0, error_types_1.isProjectsWithConflictingNamesError)(e)) {
-                projects = e.projects;
                 errors.push(e);
             }
             else {
@@ -312,18 +317,20 @@ plugins) {
         perf_hooks_1.performance.measure('build-project-configs', 'build-project-configs:start', 'build-project-configs:end');
         if (errors.length === 0) {
             return {
-                projects,
+                projects: projectRootMap,
                 externalNodes,
                 projectRootMap: rootMap,
                 sourceMaps: configurationSourceMaps,
+                matchingProjectFiles: projectFiles,
             };
         }
         else {
             throw new error_types_1.ProjectConfigurationsError(errors, {
-                projects,
+                projects: projectRootMap,
                 externalNodes,
                 projectRootMap: rootMap,
                 sourceMaps: configurationSourceMaps,
+                matchingProjectFiles: projectFiles,
             });
         }
     });
@@ -336,7 +343,8 @@ function readProjectConfigurationsFromRootMap(projectRootMap) {
     // to provide better error messaging.
     const conflicts = new Map();
     const projectRootsWithNoName = [];
-    for (const [root, configuration] of projectRootMap.entries()) {
+    for (const root in projectRootMap) {
+        const configuration = projectRootMap[root];
         // We're setting `// targets` as a comment `targets` is empty due to Project Crystal.
         // Strip it before returning configuration for usage.
         if (configuration['// targets'])
@@ -544,7 +552,8 @@ function readTargetDefaultsForTarget(targetName, targetDefaults, executor) {
 exports.readTargetDefaultsForTarget = readTargetDefaultsForTarget;
 function createRootMap(projectRootMap) {
     const map = {};
-    for (const [projectRoot, { name: projectName }] of projectRootMap) {
+    for (const projectRoot in projectRootMap) {
+        const projectName = projectRootMap[projectRoot].name;
         map[projectRoot] = projectName;
     }
     return map;

package/src/utils/perf-logging.js

@@ -1,7 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 const perf_hooks_1 = require("perf_hooks");
-if (process.env.NX_PERF_LOGGING === 'true') {
+let initialized = false;
+if (process.env.NX_PERF_LOGGING === 'true' && !initialized) {
+    initialized = true;
     const obs = new perf_hooks_1.PerformanceObserver((list) => {
         for (const entry of list.getEntries()) {
             console.log(`Time for '${entry.name}'`, entry.duration);