nx 22.6.0 → 22.6.2

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

@@ -0,0 +1,40 @@
+import { ProjectConfiguration } from '../../../config/workspace-json-project-json';
+import type { ConfigurationSourceMaps, SourceInformation } from './source-maps';
+export { validateProject } from './target-normalization';
+export declare function mergeProjectConfigurationIntoRootMap(projectRootMap: Record<string, ProjectConfiguration>, project: ProjectConfiguration, configurationSourceMaps?: ConfigurationSourceMaps, sourceInformation?: SourceInformation, skipTargetNormalization?: boolean): {
+    nameChanged: boolean;
+};
+export declare function readProjectConfigurationsFromRootMap(projectRootMap: Record<string, ProjectConfiguration>): Record<string, ProjectConfiguration>;
+export declare function createRootMap(projectRootMap: Record<string, ProjectConfiguration>): Record<string, string>;
+/**
+ * Owns the rootMap (root → ProjectConfiguration) and nameMap
+ * (name → ProjectConfiguration), coordinating merges with the
+ * {@link ProjectNameInNodePropsManager} for deferred name substitutions.
+ *
+ * The nameMap entries are the *same object references* as the rootMap
+ * entries, so when a merge adds targets to a rootMap entry the nameMap
+ * entry automatically has them too — no copying, no staleness.
+ */
+export declare class ProjectNodesManager {
+    private rootMap;
+    private nameMap;
+    private nameSubstitutionManager;
+    constructor();
+    getRootMap(): Record<string, ProjectConfiguration>;
+    /**
+     * Merges a project into the rootMap, updates the nameMap, and notifies
+     * the substitution manager if the name changed at this root.
+     */
+    mergeProjectNode(project: ProjectConfiguration, configurationSourceMaps?: ConfigurationSourceMaps, sourceInformation?: SourceInformation): void;
+    /**
+     * Registers substitutors for a plugin result's project references
+     * in `inputs` and `dependsOn`.
+     */
+    registerSubstitutors(pluginResultProjects?: Record<string, Omit<ProjectConfiguration, 'root'> & Partial<ProjectConfiguration>>): void;
+    /**
+     * Applies all pending name substitutions. Call once after all plugin
+     * results have been merged.
+     */
+    applySubstitutions(): void;
+}
+//# sourceMappingURL=project-nodes-manager.d.ts.map

package/src/project-graph/utils/project-configuration/project-nodes-manager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"project-nodes-manager.d.ts","sourceRoot":"","sources":["../../../../../../../packages/nx/src/project-graph/utils/project-configuration/project-nodes-manager.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,oBAAoB,EAAE,MAAM,6CAA6C,CAAC;AAcnF,OAAO,KAAK,EAAE,uBAAuB,EAAE,iBAAiB,EAAE,MAAM,eAAe,CAAC;AAMhF,OAAO,EAAE,eAAe,EAAE,MAAM,wBAAwB,CAAC;AAEzD,wBAAgB,oCAAoC,CAClD,cAAc,EAAE,MAAM,CAAC,MAAM,EAAE,oBAAoB,CAAC,EACpD,OAAO,EAAE,oBAAoB,EAC7B,uBAAuB,CAAC,EAAE,uBAAuB,EACjD,iBAAiB,CAAC,EAAE,iBAAiB,EAGrC,uBAAuB,CAAC,EAAE,OAAO,GAChC;IACD,WAAW,EAAE,OAAO,CAAC;CACtB,CAqLA;AAED,wBAAgB,oCAAoC,CAClD,cAAc,EAAE,MAAM,CAAC,MAAM,EAAE,oBAAoB,CAAC,wCAwCrD;AAED,wBAAgB,aAAa,CAC3B,cAAc,EAAE,MAAM,CAAC,MAAM,EAAE,oBAAoB,CAAC,0BAQrD;AAED;;;;;;;;GAQG;AACH,qBAAa,mBAAmB;IAE9B,OAAO,CAAC,OAAO,CAA4C;IAE3D,OAAO,CAAC,OAAO,CAA4C;IAC3D,OAAO,CAAC,uBAAuB,CAAgC;;IAU/D,UAAU,IAAI,MAAM,CAAC,MAAM,EAAE,oBAAoB,CAAC;IAIlD;;;OAGG;IACH,gBAAgB,CACd,OAAO,EAAE,oBAAoB,EAC7B,uBAAuB,CAAC,EAAE,uBAAuB,EACjD,iBAAiB,CAAC,EAAE,iBAAiB,GACpC,IAAI;IA+BP;;;OAGG;IACH,oBAAoB,CAClB,oBAAoB,CAAC,EAAE,MAAM,CAC3B,MAAM,EACN,IAAI,CAAC,oBAAoB,EAAE,MAAM,CAAC,GAAG,OAAO,CAAC,oBAAoB,CAAC,CACnE,GACA,IAAI;IAMP;;;OAGG;IACH,kBAAkB,IAAI,IAAI;CAG3B"}

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

@@ -0,0 +1,264 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ProjectNodesManager = exports.validateProject = void 0;
+exports.mergeProjectConfigurationIntoRootMap = mergeProjectConfigurationIntoRootMap;
+exports.readProjectConfigurationsFromRootMap = readProjectConfigurationsFromRootMap;
+exports.createRootMap = createRootMap;
+const error_types_1 = require("../../error-types");
+const target_merging_1 = require("./target-merging");
+const target_normalization_1 = require("./target-normalization");
+const name_substitution_manager_1 = require("./name-substitution-manager");
+const source_maps_1 = require("./source-maps");
+const minimatch_1 = require("minimatch");
+const globs_1 = require("../../../utils/globs");
+var target_normalization_2 = require("./target-normalization");
+Object.defineProperty(exports, "validateProject", { enumerable: true, get: function () { return target_normalization_2.validateProject; } });
+function mergeProjectConfigurationIntoRootMap(projectRootMap, project, configurationSourceMaps, sourceInformation, 
+// This function is used when reading project configuration
+// in generators, where we don't want to do this.
+skipTargetNormalization) {
+    project.root = project.root === '' ? '.' : project.root;
+    if (configurationSourceMaps && !configurationSourceMaps[project.root]) {
+        configurationSourceMaps[project.root] = {};
+    }
+    const sourceMap = configurationSourceMaps?.[project.root];
+    let matchingProject = projectRootMap[project.root];
+    if (!matchingProject) {
+        projectRootMap[project.root] = {
+            root: project.root,
+        };
+        matchingProject = projectRootMap[project.root];
+        if (sourceMap) {
+            sourceMap[`root`] = sourceInformation;
+        }
+    }
+    // This handles top level properties that are overwritten.
+    // e.g. `srcRoot`, `projectType`, or other fields that shouldn't be extended
+    // Note: `name` is set specifically here to keep it from changing. The name is
+    // always determined by the first inference plugin to ID a project, unless it has
+    // a project.json in which case it was already updated above.
+    const updatedProjectConfiguration = {
+        ...matchingProject,
+    };
+    for (const k in project) {
+        if (![
+            'tags',
+            'implicitDependencies',
+            'generators',
+            'targets',
+            'metadata',
+            'namedInputs',
+        ].includes(k)) {
+            updatedProjectConfiguration[k] = project[k];
+            if (sourceMap) {
+                sourceMap[`${k}`] = sourceInformation;
+            }
+        }
+    }
+    // The next blocks handle properties that should be themselves merged (e.g. targets, tags, and implicit dependencies)
+    if (project.tags) {
+        updatedProjectConfiguration.tags = Array.from(new Set((matchingProject.tags ?? []).concat(project.tags)));
+        if (sourceMap) {
+            sourceMap['tags'] ??= sourceInformation;
+            project.tags.forEach((tag) => {
+                sourceMap[`tags.${tag}`] = sourceInformation;
+            });
+        }
+    }
+    if (project.implicitDependencies) {
+        updatedProjectConfiguration.implicitDependencies = (matchingProject.implicitDependencies ?? []).concat(project.implicitDependencies);
+        if (sourceMap) {
+            sourceMap['implicitDependencies'] ??= sourceInformation;
+            project.implicitDependencies.forEach((implicitDependency) => {
+                sourceMap[`implicitDependencies.${implicitDependency}`] =
+                    sourceInformation;
+            });
+        }
+    }
+    if (project.generators) {
+        // Start with generators config in new project.
+        updatedProjectConfiguration.generators = { ...project.generators };
+        if (sourceMap) {
+            sourceMap['generators'] ??= sourceInformation;
+            for (const generator in project.generators) {
+                sourceMap[`generators.${generator}`] = sourceInformation;
+                for (const property in project.generators[generator]) {
+                    sourceMap[`generators.${generator}.${property}`] = sourceInformation;
+                }
+            }
+        }
+        if (matchingProject.generators) {
+            // For each generator that was already defined, shallow merge the options.
+            // Project contains the new info, so it has higher priority.
+            for (const generator in matchingProject.generators) {
+                updatedProjectConfiguration.generators[generator] = {
+                    ...matchingProject.generators[generator],
+                    ...project.generators[generator],
+                };
+            }
+        }
+    }
+    if (project.namedInputs) {
+        updatedProjectConfiguration.namedInputs = {
+            ...matchingProject.namedInputs,
+            ...project.namedInputs,
+        };
+        if (sourceMap) {
+            sourceMap['namedInputs'] ??= sourceInformation;
+            for (const namedInput in project.namedInputs) {
+                sourceMap[`namedInputs.${namedInput}`] = sourceInformation;
+            }
+        }
+    }
+    if (project.metadata) {
+        updatedProjectConfiguration.metadata = (0, target_merging_1.mergeMetadata)(sourceMap, sourceInformation, 'metadata', project.metadata, matchingProject.metadata);
+    }
+    if (project.targets) {
+        // We merge the targets with special handling, so clear this back to the
+        // targets as defined originally before merging.
+        updatedProjectConfiguration.targets = matchingProject?.targets ?? {};
+        if (sourceMap) {
+            sourceMap['targets'] ??= sourceInformation;
+        }
+        // For each target defined in the new config
+        for (const targetName in project.targets) {
+            // Always set source map info for the target, but don't overwrite info already there
+            // if augmenting an existing target.
+            const target = project.targets?.[targetName];
+            if (sourceMap) {
+                sourceMap[(0, source_maps_1.targetSourceMapKey)(targetName)] = sourceInformation;
+            }
+            const normalizedTarget = skipTargetNormalization
+                ? target
+                : (0, target_merging_1.resolveCommandSyntacticSugar)(target, project.root);
+            let matchingTargets = [];
+            if ((0, globs_1.isGlobPattern)(targetName)) {
+                // find all targets matching the glob pattern
+                // this will map atomized targets to the glob pattern same as it does for targetDefaults
+                matchingTargets = Object.keys(updatedProjectConfiguration.targets).filter((key) => (0, minimatch_1.minimatch)(key, targetName));
+            }
+            // If no matching targets were found, we can assume that the target name is not (meant to be) a glob pattern
+            if (!matchingTargets.length) {
+                matchingTargets = [targetName];
+            }
+            for (const matchingTargetName of matchingTargets) {
+                updatedProjectConfiguration.targets[matchingTargetName] =
+                    (0, target_merging_1.mergeTargetConfigurations)(normalizedTarget, matchingProject.targets?.[matchingTargetName], sourceMap, sourceInformation, `targets.${matchingTargetName}`);
+            }
+        }
+    }
+    projectRootMap[updatedProjectConfiguration.root] =
+        updatedProjectConfiguration;
+    const nameChanged = !!updatedProjectConfiguration.name &&
+        updatedProjectConfiguration.name !== matchingProject?.name;
+    return { nameChanged };
+}
+function readProjectConfigurationsFromRootMap(projectRootMap) {
+    const projects = {};
+    // If there are projects that have the same name, that is an error.
+    // This object tracks name -> (all roots of projects with that name)
+    // to provide better error messaging.
+    const conflicts = new Map();
+    const projectRootsWithNoName = [];
+    for (const root in projectRootMap) {
+        const project = projectRootMap[root];
+        // We're setting `// targets` as a comment `targets` is empty due to Project Crystal.
+        // Strip it before returning configuration for usage.
+        if (project['// targets'])
+            delete project['// targets'];
+        try {
+            (0, target_normalization_1.validateProject)(project, projects);
+            projects[project.name] = project;
+        }
+        catch (e) {
+            if ((0, error_types_1.isProjectWithNoNameError)(e)) {
+                projectRootsWithNoName.push(e.projectRoot);
+            }
+            else if ((0, error_types_1.isProjectWithExistingNameError)(e)) {
+                const rootErrors = conflicts.get(e.projectName) ?? [
+                    projects[e.projectName].root,
+                ];
+                rootErrors.push(e.projectRoot);
+                conflicts.set(e.projectName, rootErrors);
+            }
+            else {
+                throw e;
+            }
+        }
+    }
+    if (conflicts.size > 0) {
+        throw new error_types_1.MultipleProjectsWithSameNameError(conflicts, projects);
+    }
+    if (projectRootsWithNoName.length > 0) {
+        throw new error_types_1.ProjectsWithNoNameError(projectRootsWithNoName, projects);
+    }
+    return projects;
+}
+function createRootMap(projectRootMap) {
+    const map = {};
+    for (const projectRoot in projectRootMap) {
+        const projectName = projectRootMap[projectRoot].name;
+        map[projectRoot] = projectName;
+    }
+    return map;
+}
+/**
+ * Owns the rootMap (root → ProjectConfiguration) and nameMap
+ * (name → ProjectConfiguration), coordinating merges with the
+ * {@link ProjectNameInNodePropsManager} for deferred name substitutions.
+ *
+ * The nameMap entries are the *same object references* as the rootMap
+ * entries, so when a merge adds targets to a rootMap entry the nameMap
+ * entry automatically has them too — no copying, no staleness.
+ */
+class ProjectNodesManager {
+    constructor() {
+        // root → ProjectConfiguration (the merge target)
+        this.rootMap = {};
+        // name → ProjectConfiguration (same object references as rootMap)
+        this.nameMap = {};
+        // Pass a lazy accessor so the substitution manager always sees
+        // the current nameMap without manual synchronization.
+        this.nameSubstitutionManager = new name_substitution_manager_1.ProjectNameInNodePropsManager(() => this.nameMap);
+    }
+    getRootMap() {
+        return this.rootMap;
+    }
+    /**
+     * Merges a project into the rootMap, updates the nameMap, and notifies
+     * the substitution manager if the name changed at this root.
+     */
+    mergeProjectNode(project, configurationSourceMaps, sourceInformation) {
+        const previousName = this.rootMap[project.root]?.name;
+        mergeProjectConfigurationIntoRootMap(this.rootMap, project, configurationSourceMaps, sourceInformation);
+        const merged = this.rootMap[project.root];
+        const currentName = merged?.name;
+        if (currentName) {
+            // Remove old nameMap entry on rename
+            if (previousName && previousName !== currentName) {
+                delete this.nameMap[previousName];
+            }
+            // Point nameMap at the same object as rootMap
+            this.nameMap[currentName] = merged;
+            // Notify substitution manager of name change
+            if (currentName !== previousName) {
+                this.nameSubstitutionManager.identifyProjectWithRoot(project.root, currentName);
+            }
+        }
+    }
+    /**
+     * Registers substitutors for a plugin result's project references
+     * in `inputs` and `dependsOn`.
+     */
+    registerSubstitutors(pluginResultProjects) {
+        this.nameSubstitutionManager.registerSubstitutorsForNodeResults(pluginResultProjects);
+    }
+    /**
+     * Applies all pending name substitutions. Call once after all plugin
+     * results have been merged.
+     */
+    applySubstitutions() {
+        this.nameSubstitutionManager.applySubstitutions(this.rootMap);
+    }
+}
+exports.ProjectNodesManager = ProjectNodesManager;

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

@@ -0,0 +1,32 @@
+import { ProjectConfiguration, ProjectMetadata, TargetConfiguration, TargetMetadata } from '../../../config/workspace-json-project-json';
+import { TargetDefaults } from '../../../config/nx-json';
+import type { SourceInformation } from './source-maps';
+export declare function deepClone<T>(obj: T): T;
+export declare function resolveCommandSyntacticSugar(target: TargetConfiguration, key: string): TargetConfiguration;
+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;
+/**
+ * Merges two targets.
+ *
+ * Most properties from `target` will overwrite any properties from `baseTarget`.
+ * Options and configurations are treated differently - they are merged together if the executor definition is compatible.
+ *
+ * @param target The target definition with higher priority
+ * @param baseTarget The target definition that should be overwritten. Can be undefined, in which case the target is returned as-is.
+ * @param projectConfigSourceMap The source map to be filled with metadata about where each property came from
+ * @param sourceInformation The metadata about where the new target was defined
+ * @param targetIdentifier The identifier for the target to merge, used for source map
+ * @returns A merged target configuration
+ */
+export declare function mergeTargetConfigurations(target: TargetConfiguration, baseTarget?: TargetConfiguration, projectConfigSourceMap?: Record<string, SourceInformation>, sourceInformation?: SourceInformation, targetIdentifier?: string): TargetConfiguration;
+/**
+ * Checks if targets options are compatible - used when merging configurations
+ * to avoid merging options for @nx/js:tsc into something like @nx/webpack:webpack.
+ *
+ * If the executors are both specified and don't match, the options aren't considered
+ * "compatible" and shouldn't be merged.
+ */
+export declare function isCompatibleTarget(a: TargetConfiguration, b: TargetConfiguration): boolean;
+export declare function mergeTargetDefaultWithTargetDefinition(targetName: string, project: ProjectConfiguration, targetDefault: Partial<TargetConfiguration>, sourceMap: Record<string, SourceInformation>): TargetConfiguration;
+export declare function resolveNxTokensInOptions<T extends Object | Array<unknown>>(object: T, project: ProjectConfiguration, key: string): T;
+export declare function readTargetDefaultsForTarget(targetName: string, targetDefaults: TargetDefaults, executor?: string): TargetDefaults[string];
+//# sourceMappingURL=target-merging.d.ts.map

package/src/project-graph/utils/project-configuration/target-merging.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"target-merging.d.ts","sourceRoot":"","sources":["../../../../../../../packages/nx/src/project-graph/utils/project-configuration/target-merging.ts"],"names":[],"mappings":"AAEA,OAAO,EACL,oBAAoB,EACpB,eAAe,EACf,mBAAmB,EACnB,cAAc,EACf,MAAM,6CAA6C,CAAC;AACrD,OAAO,EAAE,cAAc,EAAE,MAAM,yBAAyB,CAAC;AAOzD,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,eAAe,CAAC;AAIvD,wBAAgB,SAAS,CAAC,CAAC,EAAE,GAAG,EAAE,CAAC,GAAG,CAAC,CAEtC;AAED,wBAAgB,4BAA4B,CAC1C,MAAM,EAAE,mBAAmB,EAC3B,GAAG,EAAE,MAAM,GACV,mBAAmB,CAqBrB;AAED,wBAAgB,aAAa,CAAC,CAAC,GAAG,eAAe,GAAG,cAAc,EAChE,SAAS,EAAE,MAAM,CAAC,MAAM,EAAE,CAAC,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC,EACzD,iBAAiB,EAAE,CAAC,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,EACjD,iBAAiB,EAAE,MAAM,EACzB,QAAQ,EAAE,CAAC,EACX,gBAAgB,CAAC,EAAE,CAAC,GACnB,CAAC,CA6EH;AA8DD;;;;;;;;;;;;GAYG;AACH,wBAAgB,yBAAyB,CACvC,MAAM,EAAE,mBAAmB,EAC3B,UAAU,CAAC,EAAE,mBAAmB,EAChC,sBAAsB,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,iBAAiB,CAAC,EAC1D,iBAAiB,CAAC,EAAE,iBAAiB,EACrC,gBAAgB,CAAC,EAAE,MAAM,GACxB,mBAAmB,CAyErB;AAED;;;;;;GAMG;AACH,wBAAgB,kBAAkB,CAChC,CAAC,EAAE,mBAAmB,EACtB,CAAC,EAAE,mBAAmB,WA+BvB;AAiBD,wBAAgB,sCAAsC,CACpD,UAAU,EAAE,MAAM,EAClB,OAAO,EAAE,oBAAoB,EAC7B,aAAa,EAAE,OAAO,CAAC,mBAAmB,CAAC,EAC3C,SAAS,EAAE,MAAM,CAAC,MAAM,EAAE,iBAAiB,CAAC,GAC3C,mBAAmB,CA8ErB;AAED,wBAAgB,wBAAwB,CAAC,CAAC,SAAS,MAAM,GAAG,KAAK,CAAC,OAAO,CAAC,EACxE,MAAM,EAAE,CAAC,EACT,OAAO,EAAE,oBAAoB,EAC7B,GAAG,EAAE,MAAM,GACV,CAAC,CAwBH;AAED,wBAAgB,2BAA2B,CACzC,UAAU,EAAE,MAAM,EAClB,cAAc,EAAE,cAAc,EAC9B,QAAQ,CAAC,EAAE,MAAM,GAChB,cAAc,CAAC,MAAM,CAAC,CA6BxB"}