nx 23.1.0-beta.3 → 23.1.0-beta.5

package/dist/src/command-line/init/implementation/angular/standalone-workspace.js

@@ -54,29 +54,24 @@ function createNxJson(repoRoot, angularJson, cacheableOperations, { eslintProjec
                 : []),
         ].filter(Boolean),
     };
-    nxJson.targetDefaults ??= {};
+    const defaults = { ...(nxJson.targetDefaults ?? {}) };
     if (workspaceTargets.includes('build')) {
-        nxJson.targetDefaults.build = {
-            ...nxJson.targetDefaults.build,
+        (0, utils_1.upsertTargetDefaultEntry)(defaults, 'build', {
             dependsOn: ['^build'],
             inputs: ['production', '^production'],
-        };
+        });
     }
     if (workspaceTargets.includes('server')) {
-        nxJson.targetDefaults.server = {
-            ...nxJson.targetDefaults.server,
+        (0, utils_1.upsertTargetDefaultEntry)(defaults, 'server', {
             inputs: ['production', '^production'],
-        };
+        });
     }
     if (workspaceTargets.includes('test')) {
         const inputs = ['default', '^production'];
         if ((0, fileutils_1.fileExists)((0, node_path_1.join)(repoRoot, 'karma.conf.js'))) {
             inputs.push('{workspaceRoot}/karma.conf.js');
         }
-        nxJson.targetDefaults.test = {
-            ...nxJson.targetDefaults.test,
-            inputs,
-        };
+        (0, utils_1.upsertTargetDefaultEntry)(defaults, 'test', { inputs });
     }
     if (workspaceTargets.includes('lint')) {
         const inputs = ['default'];
@@ -86,16 +81,15 @@ function createNxJson(repoRoot, angularJson, cacheableOperations, { eslintProjec
         if ((0, fileutils_1.fileExists)((0, node_path_1.join)(repoRoot, 'eslint.config.cjs'))) {
             inputs.push('{workspaceRoot}/eslint.config.cjs');
         }
-        nxJson.targetDefaults.lint = {
-            ...nxJson.targetDefaults.lint,
-            inputs,
-        };
+        (0, utils_1.upsertTargetDefaultEntry)(defaults, 'lint', { inputs });
     }
     if (workspaceTargets.includes('e2e')) {
-        nxJson.targetDefaults.e2e = {
-            ...nxJson.targetDefaults.e2e,
+        (0, utils_1.upsertTargetDefaultEntry)(defaults, 'e2e', {
             inputs: ['default', '^production'],
-        };
+        });
+    }
+    if (Object.keys(defaults).length > 0) {
+        nxJson.targetDefaults = defaults;
     }
     (0, fileutils_1.writeJsonFile)((0, node_path_1.join)(repoRoot, 'nx.json'), nxJson);
 }

package/dist/src/command-line/init/implementation/dot-nx/add-nx-scripts.d.ts

@@ -1,5 +1,6 @@
 import { Tree } from '../../../../generators/tree';
 export declare const nxWrapperPath: (p?: typeof import('path')) => string;
+export declare function getDotNxWrapperVersionCommand(platform?: NodeJS.Platform): string;
 export declare function generateDotNxSetup(version?: string): void;
 export declare function normalizeVersionForNxJson(pkg: string, version: string): string;
 export declare function writeMinimalNxJson(host: Tree, version: string): void;

package/dist/src/command-line/init/implementation/dot-nx/add-nx-scripts.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.nxWrapperPath = void 0;
+exports.getDotNxWrapperVersionCommand = getDotNxWrapperVersionCommand;
 exports.generateDotNxSetup = generateDotNxSetup;
 exports.normalizeVersionForNxJson = normalizeVersionForNxJson;
 exports.writeMinimalNxJson = writeMinimalNxJson;
@@ -50,6 +51,10 @@ const SHELL_SCRIPT_CONTENTS = [
     // Executes the nx wrapper script
     `node ${path.posix.join('$path_to_root', (0, exports.nxWrapperPath)(path.posix))} "$@"`,
 ].join('\n');
+// cmd.exe can't run the bash './nx' wrapper; use the generated nx.bat on Windows.
+function getDotNxWrapperVersionCommand(platform = process.platform) {
+    return platform === 'win32' ? '.\\nx.bat --version' : './nx --version';
+}
 function generateDotNxSetup(version) {
     const host = new tree_1.FsTree(process.cwd(), false, '.nx setup');
     writeMinimalNxJson(host, version);
@@ -66,7 +71,7 @@ function generateDotNxSetup(version) {
     // This is needed when using a global nx with dot-nx, otherwise running any nx command using global command will fail due to missing modules.
     // Pipe stderr so failures surface in telemetry instead of bare "Command failed: ./nx --version".
     try {
-        (0, child_process_1.execSync)('./nx --version', {
+        (0, child_process_1.execSync)(getDotNxWrapperVersionCommand(), {
             stdio: ['ignore', 'ignore', 'pipe'],
             encoding: 'utf8',
             windowsHide: true,

package/dist/src/command-line/init/implementation/utils.d.ts

@@ -1,9 +1,17 @@
-import { NxJsonConfiguration } from '../../../config/nx-json';
+import { NxJsonConfiguration, TargetDefaultEntry, TargetDefaults } from '../../../config/nx-json';
 import { PackageJson } from '../../../utils/package-json';
 import { PackageManagerCommands } from '../../../utils/package-manager';
 export declare function createNxJsonFile(repoRoot: string, topologicalTargets: string[], cacheableOperations: string[], scriptOutputs: {
     [name: string]: string;
 }): void;
+/**
+ * Locate-by-target upsert against an in-memory `targetDefaults` map. Merges
+ * `patch`'s config into the unfiltered (catch-all) default for `target`,
+ * promoting through the array form when one already exists. Used by `nx init`
+ * code paths that operate on raw JSON before a Tree exists — generators
+ * should use `upsertTargetDefault` from devkit instead.
+ */
+export declare function upsertTargetDefaultEntry(targetDefaults: TargetDefaults, target: string, patch: Partial<TargetDefaultEntry>): void;
 export declare function createNxJsonFromTurboJson(turboJson: Record<string, any>): NxJsonConfiguration;
 export declare function addDepsToPackageJson(repoRoot: string, additionalPackages?: string[]): void;
 export declare function updateGitIgnore(root: string): void;

package/dist/src/command-line/init/implementation/utils.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createNxJsonFile = createNxJsonFile;
+exports.upsertTargetDefaultEntry = upsertTargetDefaultEntry;
 exports.createNxJsonFromTurboJson = createNxJsonFromTurboJson;
 exports.addDepsToPackageJson = addDepsToPackageJson;
 exports.updateGitIgnore = updateGitIgnore;
@@ -34,27 +35,34 @@ function createNxJsonFile(repoRoot, topologicalTargets, cacheableOperations, scr
     }
     catch { }
     nxJson.$schema = './node_modules/nx/schemas/nx-schema.json';
-    nxJson.targetDefaults ??= {};
+    const targetDefaults = { ...(nxJson.targetDefaults ?? {}) };
     if (topologicalTargets.length > 0) {
         for (const scriptName of topologicalTargets) {
-            nxJson.targetDefaults[scriptName] ??= {};
-            nxJson.targetDefaults[scriptName] = { dependsOn: [`^${scriptName}`] };
+            upsertTargetDefaultEntry(targetDefaults, scriptName, {
+                dependsOn: [`^${scriptName}`],
+            });
         }
     }
     for (const [scriptName, output] of Object.entries(scriptOutputs)) {
         if (!output) {
             continue;
         }
-        nxJson.targetDefaults[scriptName] ??= {};
-        nxJson.targetDefaults[scriptName].outputs = [`{projectRoot}/${output}`];
+        upsertTargetDefaultEntry(targetDefaults, scriptName, {
+            outputs: [`{projectRoot}/${output}`],
+        });
     }
     for (const target of cacheableOperations) {
-        nxJson.targetDefaults[target] ??= {};
-        nxJson.targetDefaults[target].cache ??= true;
+        const existing = readUnfilteredTargetDefault(targetDefaults, target);
+        if (existing.cache === undefined) {
+            upsertTargetDefaultEntry(targetDefaults, target, { cache: true });
+        }
     }
-    if (Object.keys(nxJson.targetDefaults).length === 0) {
+    if (Object.keys(targetDefaults).length === 0) {
         delete nxJson.targetDefaults;
     }
+    else {
+        nxJson.targetDefaults = targetDefaults;
+    }
     const defaultBase = (0, deduce_default_base_1.deduceDefaultBase)();
     // Do not add defaultBase if it is inferred to be the Nx default value of main
     if (defaultBase !== 'main') {
@@ -62,6 +70,44 @@ function createNxJsonFile(repoRoot, topologicalTargets, cacheableOperations, scr
     }
     (0, fileutils_1.writeJsonFile)(nxJsonPath, nxJson);
 }
+/**
+ * Locate-by-target upsert against an in-memory `targetDefaults` map. Merges
+ * `patch`'s config into the unfiltered (catch-all) default for `target`,
+ * promoting through the array form when one already exists. Used by `nx init`
+ * code paths that operate on raw JSON before a Tree exists — generators
+ * should use `upsertTargetDefault` from devkit instead.
+ */
+function upsertTargetDefaultEntry(targetDefaults, target, patch) {
+    // Drop locator fields — the key is `target` and `nx init` only writes
+    // unfiltered defaults.
+    const { target: _t, executor: _e, projects: _p, plugin: _pl, ...config } = patch;
+    const existing = targetDefaults[target];
+    if (Array.isArray(existing)) {
+        const idx = existing.findIndex((e) => e.filter === undefined);
+        if (idx >= 0) {
+            const { filter, ...rest } = existing[idx];
+            existing[idx] = { ...rest, ...config };
+        }
+        else {
+            existing.push({ ...config });
+        }
+    }
+    else {
+        targetDefaults[target] = { ...(existing ?? {}), ...config };
+    }
+}
+/**
+ * Read the unfiltered (catch-all) config for `target` from a `targetDefaults`
+ * map — the object value, or the filter-less entry of an array value.
+ */
+function readUnfilteredTargetDefault(targetDefaults, target) {
+    const existing = targetDefaults[target];
+    if (existing === undefined)
+        return {};
+    if (!Array.isArray(existing))
+        return existing;
+    return existing.find((e) => e.filter === undefined) ?? {};
+}
 function createNxJsonFromTurboJson(turboJson) {
     const nxJson = {
         $schema: './node_modules/nx/schemas/nx-schema.json',
@@ -88,20 +134,20 @@ function createNxJsonFromTurboJson(turboJson) {
     }
     // Handle task configurations
     if (turboJson.tasks) {
-        nxJson.targetDefaults = {};
+        const targetDefaults = {};
         for (const [taskName, taskConfig] of Object.entries(turboJson.tasks)) {
             // Skip project-specific tasks (containing #)
             if (taskName.includes('#'))
                 continue;
             const config = taskConfig;
-            nxJson.targetDefaults[taskName] = {};
+            const entry = { target: taskName };
             // Handle dependsOn
             if (config.dependsOn?.length > 0) {
-                nxJson.targetDefaults[taskName].dependsOn = config.dependsOn;
+                entry.dependsOn = config.dependsOn;
             }
             // Handle inputs
             if (config.inputs?.length > 0) {
-                nxJson.targetDefaults[taskName].inputs = config.inputs
+                entry.inputs = config.inputs
                     .map((input) => {
                     if (input === '$TURBO_DEFAULT$') {
                         return '{projectRoot}/**/*';
@@ -124,7 +170,7 @@ function createNxJsonFromTurboJson(turboJson) {
             }
             // Handle outputs
             if (config.outputs?.length > 0) {
-                nxJson.targetDefaults[taskName].outputs = config.outputs.map((output) => {
+                entry.outputs = config.outputs.map((output) => {
                     // Don't add projectRoot if it's already there
                     if (output.startsWith('{projectRoot}/'))
                         return output;
@@ -136,7 +182,14 @@ function createNxJsonFromTurboJson(turboJson) {
                 });
             }
             // Handle cache setting - true by default in Turbo
-            nxJson.targetDefaults[taskName].cache = config.cache !== false;
+            entry.cache = config.cache !== false;
+            // Each turbo task maps to a unique key, written as the plain object
+            // (unfiltered) value form.
+            const { target, ...taskDefault } = entry;
+            targetDefaults[target] = taskDefault;
+        }
+        if (Object.keys(targetDefaults).length > 0) {
+            nxJson.targetDefaults = targetDefaults;
         }
     }
     /**

package/dist/src/command-line/migrate/migrate.d.ts

@@ -85,6 +85,7 @@ export declare class Migrator {
     }>;
     private createMigrateJson;
     private buildPackageJsonUpdates;
+    private resolveVersionForCascade;
     private populatePackageJsonUpdatesAndGetPackagesToCheck;
     private getPackageJsonUpdatesFromMigrationConfig;
     /**

package/dist/src/command-line/migrate/migrate.js

@@ -192,16 +192,37 @@ class Migrator {
                     !this.areIncompatiblePackagesPresent(packageUpdate.incompatibleWith) &&
                     (!this.interactive ||
                         (await this.runPackageJsonUpdatesConfirmationPrompt(packageUpdate, packageUpdateKey, packageToCheck.package)))) {
-                    Object.entries(packageUpdate.packages).forEach(([name, update]) => {
+                    const updateEntries = Object.entries(packageUpdate.packages);
+                    // Validate all up front so invalid metadata fails fast, before any
+                    // resolution does I/O.
+                    for (const [name, update] of updateEntries) {
                         this.validatePackageUpdateVersion(packageToCheck.package, name, update);
-                        filteredUpdates[name] = update;
-                        this.packageUpdates[name] = update;
-                    });
+                    }
+                    // Resolve serially: resolution can prompt (pnpm strict cooldown) and
+                    // append to minimumReleaseAgeExclude, so a serial loop avoids
+                    // overlapping prompts and keeps packageUpdates ordering stable.
+                    for (const [name, update] of updateEntries) {
+                        const resolvedUpdate = {
+                            ...update,
+                            version: await this.resolveVersionForCascade(name, update.version),
+                        };
+                        filteredUpdates[name] = resolvedUpdate;
+                        this.packageUpdates[name] = resolvedUpdate;
+                    }
                 }
             }
             await Promise.all(Object.entries(filteredUpdates).map(([name, update]) => this.buildPackageJsonUpdates(name, update)));
         }
     }
+    async resolveVersionForCascade(packageName, version) {
+        // Already a fully-qualified semver (incl. prereleases) - nothing to resolve.
+        if ((0, semver_1.valid)(version)) {
+            return version;
+        }
+        // Otherwise resolve the spec (range/tag) through the min-release-age policy,
+        // which also honors any configured minimumReleaseAgeExclude entries.
+        return (0, resolve_package_version_1.resolvePackageVersionRespectingMinReleaseAge)(packageName, version);
+    }
     async populatePackageJsonUpdatesAndGetPackagesToCheck(targetPackage, target) {
         let targetVersion = target.version;
         if (this.to[targetPackage]) {

package/dist/src/command-line/release/version/resolve-current-version.js

@@ -67,7 +67,10 @@ async function resolveCurrentVersionFromRegistry(tree, projectGraphNode, release
         return cached.currentVersion;
     }
     let registryTxt = '';
-    const spinner = spinner_1.globalSpinner.start(`Resolving the current version for ${projectGraphNode.name} from the configured registry...`);
+    // Skip non-TTY logging — the resolved version is reported through the
+    // project's batched `ProjectLogger` so the spinner step shouldn't emit an
+    // out-of-band line that would bypass the grouped output.
+    const spinner = spinner_1.globalSpinner.start(`Resolving the current version for ${projectGraphNode.name} from the configured registry...`, undefined, { skipNonTtyLogging: true });
     try {
         const res = await versionActions.readCurrentVersionFromRegistry(tree, finalConfigForProject.currentVersionResolverMetadata);
         if (!res) {

package/dist/src/command-line/show/show-target/info.js

@@ -20,10 +20,9 @@ function resolveTargetInfoData(t) {
             allTargetNames.add(name);
         }
     }
-    const extraTargetDeps = Object.fromEntries(Object.entries(nxJson.targetDefaults ?? {})
-        .filter(([, config]) => config.dependsOn)
-        .map(([name, config]) => [name, config.dependsOn]));
-    const depConfigs = (0, utils_1.getDependencyConfigs)({ project: projectName, target: targetName }, extraTargetDeps, graph, [...allTargetNames]) ?? [];
+    const depConfigs = (0, utils_1.getDependencyConfigs)({ project: projectName, target: targetName }, 
+    // no programmatic extras — `dependsOn` is already merged into the graph node
+    {}, graph, [...allTargetNames]) ?? [];
     // Determine the hoisted command value and which option key it came from
     let command;
     let commandSourceKey;
@@ -44,7 +43,7 @@ function resolveTargetInfoData(t) {
         command = targetConfig.options.script;
         commandSourceKey = 'options.script';
     }
-    const { dependsOn, depSourceIndices, transitiveTasks } = resolveTaskGraphDependencies(graph, extraTargetDeps, projectName, targetName, configuration, depConfigs);
+    const { dependsOn, depSourceIndices, transitiveTasks } = resolveTaskGraphDependencies(graph, {}, projectName, targetName, configuration, depConfigs);
     const configurations = Object.keys(targetConfig.configurations ?? {});
     const targetSourceMap = extractTargetSourceMap(node.data.root, targetName, sourceMaps);
     const usesCustomHasher = (0, utils_2.hasCustomHasher)(projectName, targetName, graph);

package/dist/src/config/nx-json.d.ts

@@ -20,7 +20,96 @@ export interface NxAffectedConfig {
      */
     defaultBase?: string;
 }
-export type TargetDefaults = Record<string, Partial<TargetConfiguration>>;
+/**
+ * A logical, flat view of a single target default — the shape devkit helpers
+ * (`upsertTargetDefault` / `findTargetDefault`) and generators author and read.
+ * It is **not** the on-disk shape: `upsertTargetDefault` translates it into the
+ * map-and-array storage form ({@link TargetDefaults}), and `findTargetDefault`
+ * resolves the storage form back to one of these flat entries. Keeping this
+ * flat shape stable is what lets generator call sites read `e.target` /
+ * `e.projects` / `e.plugin` without knowing about `filter`.
+ *
+ * Either `target` or `executor` locates the entry; `projects` / `plugin`
+ * narrow it; the remaining `TargetConfiguration` fields are the payload.
+ */
+export type TargetDefaultEntry = {
+    /** Target name or glob pattern (e.g. `build`, `e2e-ci--*`). */
+    target?: string;
+    /** Executor the default applies to (e.g. `@nx/js:tsc`). */
+    executor?: string;
+    /**
+     * Restrict the default to a subset of projects. Accepts any patterns
+     * supported by `findMatchingProjects`.
+     */
+    projects?: string[];
+    /** Restrict the default to targets originated by a specific plugin. */
+    plugin?: string;
+} & Partial<TargetConfiguration>;
+/**
+ * The `filter` namespace narrows where a {@link TargetDefaultArrayEntry}
+ * applies. An entry with no `filter` is a catch-all baseline that applies to
+ * every variant of its target key; an entry with a `filter` applies only
+ * where the listed criteria all match.
+ */
+export type TargetDefaultFilter = {
+    /**
+     * Restrict the default to targets originated by a specific plugin
+     * (e.g. `@nx/vite`). Matches against the plugin that wrote the target's
+     * `executor` or `command`.
+     */
+    plugin?: string;
+    /**
+     * Restrict the default to a subset of projects. Accepts any patterns
+     * supported by `findMatchingProjects` (project names, globs, `tag:foo`,
+     * directory globs, negation with `!`).
+     */
+    projects?: string[];
+    /**
+     * Restrict the default to targets that resolve to a specific executor
+     * (e.g. `@nx/jest:jest`). This narrows *within* a named target key, in
+     * addition to the long-standing top-level executor-key form.
+     */
+    executor?: string;
+};
+/**
+ * A single entry in the array-shaped value of a `targetDefaults` key.
+ * Carries an optional {@link TargetDefaultFilter} alongside the
+ * `TargetConfiguration` fields that get applied when the filter matches.
+ *
+ * Within a key's array, entries apply in document order, last match winning.
+ */
+export type TargetDefaultArrayEntry = {
+    filter?: TargetDefaultFilter;
+} & Partial<TargetConfiguration>;
+/**
+ * The value stored under a `targetDefaults` key. Either today's plain config
+ * object (used when no filtering is needed) or an ordered array of filtered
+ * entries (used once a key needs to vary defaults by plugin/projects/executor).
+ *
+ * The two forms are equivalent for the unfiltered case: `{ cache: true }` and
+ * `[{ cache: true }]` mean the same thing.
+ *
+ * `filter` is only meaningful on array entries; the bare object form forbids it
+ * (`filter?: never`) so a stray filter on the unfiltered form is a type error
+ * rather than a silently-ignored field.
+ */
+export type TargetDefaultValue = (Partial<TargetConfiguration> & {
+    filter?: never;
+}) | TargetDefaultArrayEntry[];
+/**
+ * `targetDefaults` is a map keyed by logical target name (`build`, `test`),
+ * glob (`e2e-ci--*`), or executor (`@nx/js:tsc`). Each value is either a plain
+ * config object or an ordered array of filtered entries — see
+ * {@link TargetDefaultValue}. The map shape is additive: existing record-shaped
+ * configs remain valid because every value is allowed to be a bare object.
+ */
+export type TargetDefaults = Record<string, TargetDefaultValue>;
+/**
+ * Internal-only: the post-normalization shape consumed by the nx core matcher.
+ * Every key's value is normalized to an array, so a bare object value is
+ * wrapped into a single-element `[entry]`.
+ */
+export type NormalizedTargetDefaults = Record<string, TargetDefaultArrayEntry[]>;
 export type TargetDependencies = Record<string, (TargetDependencyConfig | string)[]>;
 export interface NrwlJsPluginConfig {
     analyzeSourceFiles?: boolean;
@@ -691,7 +780,9 @@ export interface NxJsonConfiguration<T = '*' | string[]> {
         [inputName: string]: (string | InputDefinition)[];
     };
     /**
-     * Dependencies between different target names across all projects
+     * Default configuration applied to targets across all projects. Entries
+     * match targets by target name and/or executor, optionally narrowed by
+     * the `projects` and `plugin` filters.
      */
     targetDefaults?: TargetDefaults;
     /**