nx 22.7.0 → 23.0.0-beta.0

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

@@ -1,7 +1,7 @@
 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): {
+export declare function mergeProjectConfigurationIntoRootMap(projectRootMap: Record<string, ProjectConfiguration>, project: ProjectConfiguration, configurationSourceMaps?: ConfigurationSourceMaps, sourceInformation?: SourceInformation, skipTargetNormalization?: boolean, deferSpreadsWithoutBase?: boolean): {
     nameChanged: boolean;
 };
 export declare function readProjectConfigurationsFromRootMap(projectRootMap: Record<string, ProjectConfiguration>): Record<string, ProjectConfiguration>;
@@ -27,10 +27,16 @@ export declare class ProjectNodesManager {
      */
     mergeProjectNode(project: ProjectConfiguration, configurationSourceMaps?: ConfigurationSourceMaps, sourceInformation?: SourceInformation): void;
     /**
-     * Registers substitutors for a plugin result's project references
-     * in `inputs` and `dependsOn`.
+     * Inserts project-name sentinels into `inputs` and `dependsOn` on the
+     * merged objects from `mergedRootMap` (defaulting to this manager's
+     * rootMap). Walking the merged entries matters because a spread-produced
+     * array is a fresh instance.
+     *
+     * Pass a different `mergedRootMap` for the default-plugin intermediate
+     * pass, then call again with `this.rootMap` after it's applied so
+     * sentinel parents rebind onto the final arrays.
      */
-    registerSubstitutors(pluginResultProjects?: Record<string, Omit<ProjectConfiguration, 'root'> & Partial<ProjectConfiguration>>): void;
+    registerNameRefs(pluginResultProjects?: Record<string, Omit<ProjectConfiguration, 'root'> & Partial<ProjectConfiguration>>, mergedRootMap?: Record<string, ProjectConfiguration>): void;
     /**
      * Applies all pending name substitutions. Call once after all plugin
      * results have been merged.

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

@@ -16,7 +16,7 @@ Object.defineProperty(exports, "validateProject", { enumerable: true, get: funct
 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) {
+skipTargetNormalization, deferSpreadsWithoutBase) {
     project.root = project.root === '' ? '.' : project.root;
     if (configurationSourceMaps && !configurationSourceMaps[project.root]) {
         configurationSourceMaps[project.root] = {};
@@ -143,7 +143,7 @@ skipTargetNormalization) {
             }
             for (const matchingTargetName of matchingTargets) {
                 updatedProjectConfiguration.targets[matchingTargetName] =
-                    (0, target_merging_1.mergeTargetConfigurations)(normalizedTarget, matchingProject.targets?.[matchingTargetName], sourceMap, sourceInformation, `targets.${matchingTargetName}`);
+                    (0, target_merging_1.mergeTargetConfigurations)(normalizedTarget, matchingProject.targets?.[matchingTargetName], sourceMap, sourceInformation, `targets.${matchingTargetName}`, deferSpreadsWithoutBase);
             }
         }
     }
@@ -217,8 +217,8 @@ class ProjectNodesManager {
         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.
+        // 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() {
@@ -247,11 +247,25 @@ class ProjectNodesManager {
         }
     }
     /**
-     * Registers substitutors for a plugin result's project references
-     * in `inputs` and `dependsOn`.
+     * Inserts project-name sentinels into `inputs` and `dependsOn` on the
+     * merged objects from `mergedRootMap` (defaulting to this manager's
+     * rootMap). Walking the merged entries matters because a spread-produced
+     * array is a fresh instance.
+     *
+     * Pass a different `mergedRootMap` for the default-plugin intermediate
+     * pass, then call again with `this.rootMap` after it's applied so
+     * sentinel parents rebind onto the final arrays.
      */
-    registerSubstitutors(pluginResultProjects) {
-        this.nameSubstitutionManager.registerSubstitutorsForNodeResults(pluginResultProjects);
+    registerNameRefs(pluginResultProjects, mergedRootMap = this.rootMap) {
+        if (!pluginResultProjects)
+            return;
+        const scoped = {};
+        for (const root in pluginResultProjects) {
+            if (mergedRootMap[root]) {
+                scoped[root] = mergedRootMap[root];
+            }
+        }
+        this.nameSubstitutionManager.registerNameRefs(scoped);
     }
     /**
      * Applies all pending name substitutions. Call once after all plugin

package/dist/src/project-graph/utils/project-configuration/source-maps.d.ts

@@ -1,69 +1,12 @@
-/**
- * Utilities for constructing source map keys used to track the origin
- * of project configuration properties. Source map keys are dot-delimited
- * paths into a ProjectConfiguration, e.g. `targets.build.inputs.0.projects`.
- *
- * Centralizing key construction here prevents typos and ensures consistent
- * key shapes across the project graph build pipeline.
- */
-/** Describes the file and plugin that contributed a given configuration property. */
+/** [file, plugin] that contributed a configuration property. */
 export type SourceInformation = [file: string | null, plugin: string];
-/** Maps each project root to a source map for its configuration properties. */
+/** Source map per project root. */
 export type ConfigurationSourceMaps = Record<string, Record<string, SourceInformation>>;
-/**
- * Calls `callback` with the source map key for each index of `array` under
- * `prefixKey`, producing keys like `${prefixKey}.0`, `${prefixKey}.1`, etc.
- *
- * Use this when you need the keys themselves — e.g. to register or clear
- * entries in a name substitution manager — without necessarily writing to a
- * source map.
- *
- * @param prefixKey The dot-delimited path prefix for the array (e.g. `"targets.build.inputs"`).
- * @param array The array whose indices should be iterated.
- * @param callback Called with the key for each index.
- * @param startIndex Index to start from. Useful when appending to an existing array.
- */
 export declare function forEachSourceMapKeyForArray(prefixKey: string, array: unknown[], callback: (key: string, index: number) => void, startIndex?: number): void;
-/**
- * Records a single source map entry. Prefer this over direct bracket
- * assignment to keep writes consistent with the rest of the source map API.
- */
+export declare function readArrayItemSourceInfo(sourceMap: Record<string, SourceInformation>, arrayKey: string, itemIndex: number): SourceInformation | undefined;
+export declare function readObjectPropertySourceInfo(sourceMap: Record<string, SourceInformation>, objectKey: string, propertyKey: string): SourceInformation | undefined;
 export declare function recordSourceMapInfo(sourceMap: Record<string, SourceInformation>, key: string, sourceInfo: SourceInformation): void;
-/**
- * Convenience wrapper that records a source map entry for each index of
- * `array` under `prefixKey`. Equivalent to calling {@link forEachSourceMapKeyForArray}
- * and {@link recordSourceMapInfo} together.
- *
- * @param sourceMap The source map to write into.
- * @param prefixKey The dot-delimited path prefix for the array (e.g. `"targets.build.inputs"`).
- * @param array The array whose indices should be recorded.
- * @param sourceInfo The source information to associate with each index key.
- * @param startIndex Index to start writing from. Useful when appending to an existing array.
- */
 export declare function recordSourceMapKeysByIndex(sourceMap: Record<string, SourceInformation>, prefixKey: string, array: unknown[], sourceInfo: SourceInformation, startIndex?: number): void;
-/**
- * Builds a source map key for a target entry.
- *
- * @example
- * // Returns "targets.build"
- * targetSourceMapKey('build')
- */
 export declare function targetSourceMapKey(targetName: string): string;
-/**
- * Builds a source map key for a specific option within a target.
- *
- * @example
- * // Returns "targets.build.options.outputPath"
- * targetOptionSourceMapKey('build', 'outputPath')
- */
 export declare function targetOptionSourceMapKey(targetName: string, optionKey: string): string;
-/**
- * Builds a source map key for a target's configurations section, optionally
- * scoped to a specific configuration name and key within it.
- *
- * @example
- * targetConfigurationsSourceMapKey('build')                         // "targets.build.configurations"
- * targetConfigurationsSourceMapKey('build', 'production')           // "targets.build.configurations.production"
- * targetConfigurationsSourceMapKey('build', 'production', 'outputHashing') // "targets.build.configurations.production.outputHashing"
- */
 export declare function targetConfigurationsSourceMapKey(targetName: string, configurationName?: string, configurationKey?: string): string;

package/dist/src/project-graph/utils/project-configuration/source-maps.js

@@ -1,87 +1,42 @@
 "use strict";
-/**
- * Utilities for constructing source map keys used to track the origin
- * of project configuration properties. Source map keys are dot-delimited
- * paths into a ProjectConfiguration, e.g. `targets.build.inputs.0.projects`.
- *
- * Centralizing key construction here prevents typos and ensures consistent
- * key shapes across the project graph build pipeline.
- */
+// Source map keys are dot-delimited paths into a ProjectConfiguration,
+// e.g. `targets.build.inputs.0.projects`.
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.forEachSourceMapKeyForArray = forEachSourceMapKeyForArray;
+exports.readArrayItemSourceInfo = readArrayItemSourceInfo;
+exports.readObjectPropertySourceInfo = readObjectPropertySourceInfo;
 exports.recordSourceMapInfo = recordSourceMapInfo;
 exports.recordSourceMapKeysByIndex = recordSourceMapKeysByIndex;
 exports.targetSourceMapKey = targetSourceMapKey;
 exports.targetOptionSourceMapKey = targetOptionSourceMapKey;
 exports.targetConfigurationsSourceMapKey = targetConfigurationsSourceMapKey;
-/**
- * Calls `callback` with the source map key for each index of `array` under
- * `prefixKey`, producing keys like `${prefixKey}.0`, `${prefixKey}.1`, etc.
- *
- * Use this when you need the keys themselves — e.g. to register or clear
- * entries in a name substitution manager — without necessarily writing to a
- * source map.
- *
- * @param prefixKey The dot-delimited path prefix for the array (e.g. `"targets.build.inputs"`).
- * @param array The array whose indices should be iterated.
- * @param callback Called with the key for each index.
- * @param startIndex Index to start from. Useful when appending to an existing array.
- */
+// Iterates `${prefixKey}.0`, `${prefixKey}.1`, ... for each index of `array`.
 function forEachSourceMapKeyForArray(prefixKey, array, callback, startIndex = 0) {
     for (let i = startIndex; i < array.length; i++) {
         callback(`${prefixKey}.${i}`, i);
     }
 }
-/**
- * Records a single source map entry. Prefer this over direct bracket
- * assignment to keep writes consistent with the rest of the source map API.
- */
+// Reads per-index source info, falling back to the array's top-level entry.
+function readArrayItemSourceInfo(sourceMap, arrayKey, itemIndex) {
+    return sourceMap[`${arrayKey}.${itemIndex}`] ?? sourceMap[arrayKey];
+}
+// Reads per-property source info, falling back to the object's top-level entry.
+function readObjectPropertySourceInfo(sourceMap, objectKey, propertyKey) {
+    return sourceMap[`${objectKey}.${propertyKey}`] ?? sourceMap[objectKey];
+}
 function recordSourceMapInfo(sourceMap, key, sourceInfo) {
     sourceMap[key] = sourceInfo;
 }
-/**
- * Convenience wrapper that records a source map entry for each index of
- * `array` under `prefixKey`. Equivalent to calling {@link forEachSourceMapKeyForArray}
- * and {@link recordSourceMapInfo} together.
- *
- * @param sourceMap The source map to write into.
- * @param prefixKey The dot-delimited path prefix for the array (e.g. `"targets.build.inputs"`).
- * @param array The array whose indices should be recorded.
- * @param sourceInfo The source information to associate with each index key.
- * @param startIndex Index to start writing from. Useful when appending to an existing array.
- */
+// Records the same source info under every `${prefixKey}.${i}` entry.
 function recordSourceMapKeysByIndex(sourceMap, prefixKey, array, sourceInfo, startIndex = 0) {
     forEachSourceMapKeyForArray(prefixKey, array, (key) => recordSourceMapInfo(sourceMap, key, sourceInfo), startIndex);
 }
-/**
- * Builds a source map key for a target entry.
- *
- * @example
- * // Returns "targets.build"
- * targetSourceMapKey('build')
- */
 function targetSourceMapKey(targetName) {
     return `targets.${targetName}`;
 }
-/**
- * Builds a source map key for a specific option within a target.
- *
- * @example
- * // Returns "targets.build.options.outputPath"
- * targetOptionSourceMapKey('build', 'outputPath')
- */
 function targetOptionSourceMapKey(targetName, optionKey) {
     return `targets.${targetName}.options.${optionKey}`;
 }
-/**
- * Builds a source map key for a target's configurations section, optionally
- * scoped to a specific configuration name and key within it.
- *
- * @example
- * targetConfigurationsSourceMapKey('build')                         // "targets.build.configurations"
- * targetConfigurationsSourceMapKey('build', 'production')           // "targets.build.configurations.production"
- * targetConfigurationsSourceMapKey('build', 'production', 'outputHashing') // "targets.build.configurations.production.outputHashing"
- */
 function targetConfigurationsSourceMapKey(targetName, configurationName, configurationKey) {
     let key = `targets.${targetName}.configurations`;
     if (configurationName) {

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

@@ -0,0 +1,16 @@
+import { NxJsonConfiguration, TargetDefaults } from '../../../config/nx-json';
+import { ProjectConfiguration } from '../../../config/workspace-json-project-json';
+import type { CreateNodesResult } from '../../plugins/public-api';
+type CreateNodesResultEntry = readonly [
+    plugin: string,
+    file: string,
+    result: CreateNodesResult,
+    pluginIndex?: number
+];
+/**
+ * Builds a synthetic plugin result from nx.json's `targetDefaults`, layered
+ * between specified-plugin and default-plugin results during merging.
+ */
+export declare function createTargetDefaultsResults(specifiedPluginRootMap: Record<string, ProjectConfiguration>, defaultPluginRootMap: Record<string, ProjectConfiguration>, nxJsonConfiguration: NxJsonConfiguration): CreateNodesResultEntry[];
+export declare function readTargetDefaultsForTarget(targetName: string, targetDefaults: TargetDefaults, executor?: string): TargetDefaults[string];
+export {};

package/dist/src/project-graph/utils/project-configuration/target-defaults.js

@@ -0,0 +1,117 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createTargetDefaultsResults = createTargetDefaultsResults;
+exports.readTargetDefaultsForTarget = readTargetDefaultsForTarget;
+const minimatch_1 = require("minimatch");
+const globs_1 = require("../../../utils/globs");
+const target_merging_1 = require("./target-merging");
+const utils_1 = require("./utils");
+/**
+ * Builds a synthetic plugin result from nx.json's `targetDefaults`, layered
+ * between specified-plugin and default-plugin results during merging.
+ */
+function createTargetDefaultsResults(specifiedPluginRootMap, defaultPluginRootMap, nxJsonConfiguration) {
+    const targetDefaultsConfig = nxJsonConfiguration.targetDefaults;
+    if (!targetDefaultsConfig) {
+        return [];
+    }
+    const syntheticProjects = {};
+    const allRoots = new Set([
+        ...Object.keys(specifiedPluginRootMap),
+        ...Object.keys(defaultPluginRootMap),
+    ]);
+    for (const root of allRoots) {
+        const specifiedTargets = specifiedPluginRootMap[root]?.targets ?? {};
+        const defaultTargets = defaultPluginRootMap[root]?.targets ?? {};
+        for (const targetName of (0, utils_1.uniqueKeysInObjects)(specifiedTargets, defaultTargets)) {
+            const syntheticTarget = buildSyntheticTargetForRoot(targetName, root, specifiedTargets[targetName], defaultTargets[targetName], targetDefaultsConfig);
+            if (!syntheticTarget)
+                continue;
+            syntheticProjects[root] ??= { root, targets: {} };
+            syntheticProjects[root].targets[targetName] = syntheticTarget;
+        }
+    }
+    if (Object.keys(syntheticProjects).length === 0) {
+        return [];
+    }
+    return [
+        [
+            'nx/target-defaults',
+            'nx.json',
+            {
+                projects: syntheticProjects,
+            },
+        ],
+    ];
+}
+// Returns the synthetic defaults target to insert for `targetName` at
+// `root`, or undefined if no defaults apply.
+// Layering: specified plugins < target defaults < default plugins.
+function buildSyntheticTargetForRoot(targetName, root, specifiedTarget, defaultTarget, targetDefaultsConfig) {
+    const resolvedSpecified = specifiedTarget
+        ? (0, target_merging_1.resolveCommandSyntacticSugar)(specifiedTarget, root)
+        : undefined;
+    const resolvedDefault = defaultTarget
+        ? (0, target_merging_1.resolveCommandSyntacticSugar)(defaultTarget, root)
+        : undefined;
+    // Specified-only: layer defaults on top; the downstream merge handles
+    // executor mismatches by replacing.
+    if (resolvedSpecified && !resolvedDefault) {
+        return readAndPrepareTargetDefaults(targetName, resolvedSpecified.executor, root, targetDefaultsConfig);
+    }
+    // Default-only.
+    if (resolvedDefault && !resolvedSpecified) {
+        return readAndPrepareTargetDefaults(targetName, resolvedDefault.executor, root, targetDefaultsConfig);
+    }
+    if (!resolvedSpecified || !resolvedDefault)
+        return undefined;
+    // Both compatible: use the default plugin's executor for the lookup.
+    if ((0, target_merging_1.isCompatibleTarget)(resolvedSpecified, resolvedDefault)) {
+        return readAndPrepareTargetDefaults(targetName, resolvedDefault.executor || resolvedSpecified.executor, root, targetDefaultsConfig);
+    }
+    // Incompatible: default plugin will replace specified; only defaults
+    // matching the default plugin's executor are useful.
+    const targetDefaults = readAndPrepareTargetDefaults(targetName, resolvedDefault.executor, root, targetDefaultsConfig);
+    if (targetDefaults && (0, target_merging_1.isCompatibleTarget)(resolvedDefault, targetDefaults)) {
+        // Stamp executor/command so the default layer merges cleanly on top.
+        return {
+            ...targetDefaults,
+            executor: resolvedDefault.executor,
+            command: resolvedDefault.command,
+        };
+    }
+    return undefined;
+}
+function readAndPrepareTargetDefaults(targetName, executor, root, targetDefaultsConfig) {
+    const rawTargetDefaults = readTargetDefaultsForTarget(targetName, targetDefaultsConfig, executor);
+    if (!rawTargetDefaults)
+        return undefined;
+    return (0, target_merging_1.resolveCommandSyntacticSugar)((0, target_merging_1.deepClone)(rawTargetDefaults), root);
+}
+function readTargetDefaultsForTarget(targetName, targetDefaults, executor) {
+    if (executor && targetDefaults?.[executor]) {
+        // If an executor is defined in project.json, defaults should be read
+        // from the most specific key that matches that executor.
+        // e.g. If executor === run-commands, and the target is named build:
+        // Use, use nx:run-commands if it is present
+        // If not, use build if it is present.
+        return targetDefaults?.[executor];
+    }
+    else if (targetDefaults?.[targetName]) {
+        // If the executor is not defined, the only key we have is the target name.
+        return targetDefaults?.[targetName];
+    }
+    let matchingTargetDefaultKey = null;
+    for (const key in targetDefaults ?? {}) {
+        if ((0, globs_1.isGlobPattern)(key) && (0, minimatch_1.minimatch)(targetName, key)) {
+            if (!matchingTargetDefaultKey ||
+                matchingTargetDefaultKey.length < key.length) {
+                matchingTargetDefaultKey = key;
+            }
+        }
+    }
+    if (matchingTargetDefaultKey) {
+        return targetDefaults[matchingTargetDefaultKey];
+    }
+    return null;
+}

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

@@ -1,5 +1,4 @@
 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;
@@ -17,7 +16,7 @@ export declare function mergeMetadata<T = ProjectMetadata | TargetMetadata>(sour
  * @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;
+export declare function mergeTargetConfigurations(target: TargetConfiguration, baseTarget?: TargetConfiguration, projectConfigSourceMap?: Record<string, SourceInformation>, sourceInformation?: SourceInformation, targetIdentifier?: string, deferSpreadsWithoutBase?: boolean): 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.
@@ -26,6 +25,4 @@ export declare function mergeTargetConfigurations(target: TargetConfiguration, b
  * "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];