nx 23.0.0-beta.2 → 23.0.0-beta.21

package/dist/src/index.js

@@ -1,5 +1,2 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.initTasksRunner = void 0;
-var init_tasks_runner_1 = require("./tasks-runner/init-tasks-runner");
-Object.defineProperty(exports, "initTasksRunner", { enumerable: true, get: function () { return init_tasks_runner_1.initTasksRunner; } });

package/dist/src/migrations/update-16-2-0/remove-run-commands-output-path.js

@@ -18,8 +18,12 @@ async function removeRunCommandsOutputPath(tree) {
     }
     if (tree.exists('nx.json')) {
         (0, json_1.updateJson)(tree, 'nx.json', (json) => {
-            for (const [, target] of Object.entries(json.targetDefaults ?? {})) {
-                updateTargetBlock(target);
+            const td = json.targetDefaults;
+            if (td) {
+                const entries = Array.isArray(td) ? td : Object.values(td);
+                for (const entry of entries) {
+                    updateTargetBlock(entry);
+                }
             }
             return json;
         });

package/dist/src/migrations/update-17-0-0/move-cache-directory.md

@@ -0,0 +1,31 @@
+#### Sample Code Changes
+
+Add `.nx/cache` to the `.gitignore` file.
+
+##### Before
+
+```text title=".gitignore"
+node_modules
+```
+
+##### After
+
+```text title=".gitignore" {2}
+node_modules
+.nx/cache
+```
+
+Add `.nx/cache` to the `.prettierignore` file.
+
+##### Before
+
+```ts title=".prettierignore"
+/dist
+```
+
+##### After
+
+```ts title=".prettierignore" {2}
+/dist
+.nx/cache
+```

package/dist/src/migrations/update-17-0-0/use-minimal-config-for-tasks-runner-options.js

@@ -57,10 +57,26 @@ async function migrate(tree) {
             delete options.cacheDirectory;
         }
         if (Array.isArray(options.cacheableOperations)) {
-            nxJson.targetDefaults ??= {};
-            for (const target of options.cacheableOperations) {
-                nxJson.targetDefaults[target] ??= {};
-                nxJson.targetDefaults[target].cache ??= true;
+            if (Array.isArray(nxJson.targetDefaults)) {
+                for (const target of options.cacheableOperations) {
+                    const idx = nxJson.targetDefaults.findIndex((e) => e.target === target &&
+                        e.executor === undefined &&
+                        e.projects === undefined &&
+                        e.plugin === undefined);
+                    if (idx >= 0) {
+                        nxJson.targetDefaults[idx].cache ??= true;
+                    }
+                    else {
+                        nxJson.targetDefaults.push({ target, cache: true });
+                    }
+                }
+            }
+            else {
+                nxJson.targetDefaults ??= {};
+                for (const target of options.cacheableOperations) {
+                    nxJson.targetDefaults[target] ??= {};
+                    nxJson.targetDefaults[target].cache ??= true;
+                }
             }
             delete options.cacheableOperations;
         }

package/dist/src/migrations/update-20-0-0/move-use-daemon-process.md

@@ -0,0 +1,27 @@
+#### Move useDaemonProcess
+
+Move the `useDaemonProcess` to the root of `nx.json`
+
+#### Sample Code Changes
+
+##### Before
+
+```json title="nx.json"
+{
+  "tasksRunnerOptions": {
+    "default": {
+      "options": {
+        "useDaemonProcess": false
+      }
+    }
+  }
+}
+```
+
+##### After
+
+```json title="nx.json"
+{
+  "useDaemonProcess": false
+}
+```

package/dist/src/migrations/update-20-0-1/use-legacy-cache.md

@@ -0,0 +1,24 @@
+#### Use Legacy Cache
+
+Set `useLegacyCache` to true for migrating workspaces
+
+#### Sample Code Changes
+
+Add `useLegacyCache` to `nx.json` unless `enableDbCache` was set to true.
+
+##### Before
+
+```json title="nx.json"
+{
+  "targetDefaults": {}
+}
+```
+
+##### After
+
+```json title="nx.json"
+{
+  "targetDefaults": {},
+  "useLegacyCache": true
+}
+```

package/dist/src/migrations/update-21-0-0/release-changelog-config-changes.md

@@ -0,0 +1,49 @@
+#### Nx Release Changelog Config Changes
+
+In Nx v21, the `mapAuthorsToGitHubUsernames` changelog "renderOption" for the default changelog renderer was renamed to `applyUsernameToAuthors` to reflect the fact that it is no longer specific to GitHub. Most people were not setting this option directly, but if you were, it will be automatically migrated by this migration.
+
+The migration will also update release groups changelog configuration, if applicable.
+
+#### Sample Code Changes
+
+##### Before
+
+```json title="nx.json"
+{
+  "release": {
+    "changelog": {
+      "workspaceChangelog": {
+        "renderOptions": {
+          "mapAuthorsToGitHubUsernames": true
+        }
+      },
+      "projectChangelogs": {
+        "renderOptions": {
+          "mapAuthorsToGitHubUsernames": false
+        }
+      }
+    }
+  }
+}
+```
+
+##### After
+
+```json title="nx.json"
+{
+  "release": {
+    "changelog": {
+      "workspaceChangelog": {
+        "renderOptions": {
+          "applyUsernameToAuthors": true
+        }
+      },
+      "projectChangelogs": {
+        "renderOptions": {
+          "applyUsernameToAuthors": false
+        }
+      }
+    }
+  }
+}
+```

package/dist/src/migrations/update-21-0-0/release-version-config-changes.md

@@ -0,0 +1,54 @@
+#### Nx Release Version Config Changes
+
+In Nx v21, the implementation details of versioning were rewritten to massively enhance flexibility and lay the groundwork for future features.
+
+As part of this, some elements of the release configuration were updated. During the lifecycle of Nx v21, you can still opt into the old versioning by setting `release.version.useLegacyVersioning` to `true`, in which case the release configuration should remain unchanged.
+
+In Nx v22, the legacy versioning implementation will be removed entirely and the configuration will have to be updated to match what this migration does for you.
+
+#### Sample Code Changes
+
+"generatorOptions" is longer exists and most non-ecosystem specific options have moved to the top level of "version" and are therefore fully documented on the JSON schema as a core option.
+
+"packageRoot: string" has been replaced by the more flexible concept of "manifestRootsToUpdate: string[]", allowing for multiple manifest files (such as `package.json` in the JS/TS ecosystem)
+to be updated in a single versioning run.
+
+Ecosystem specific options, such as "skipLockFileUpdate", which is specific to the JS/TS ecosystem, are available via the new "versionActionsOptions" object, which is so named because of the new `VersionActions` abstraction introduced in Nx v21,
+which allows for different ecosystems and use-cases to be supported via very minimal implementation effort.
+
+"preserveLocalDependencyProtocols" changed from `false` by default to `true` by default in Nx v21, so it can simply be removed from the configuration when set to true.
+
+The migration will also update release groups version configuration, as well as project.json and package.json version configuration, if applicable.
+
+##### Before
+
+```json title="nx.json"
+{
+  "release": {
+    "version": {
+      "generatorOptions": {
+        "packageRoot": "build/packages/{projectName}",
+        "currentVersionResolver": "registry",
+        "skipLockFileUpdate": true,
+        "preserveLocalDependencyProtocols": true
+      }
+    }
+  }
+}
+```
+
+##### After
+
+```json title="nx.json"
+{
+  "release": {
+    "version": {
+      "manifestRootsToUpdate": ["build/packages/{projectName}"],
+      "currentVersionResolver": "registry",
+      "versionActionsOptions": {
+        "skipLockFileUpdate": true
+      }
+    }
+  }
+}
+```

package/dist/src/migrations/update-21-0-0/remove-custom-tasks-runner.md

@@ -0,0 +1,28 @@
+#### Remove Custom Tasks Runners
+
+Removes `tasksRunnerOptions` entries from `nx.json` that contain custom tasks runners. In Nx 21, custom tasks runners are no longer functional. See /deprecated/custom-tasks-runner for more information.
+
+#### Sample Code Changes
+
+Removes custom task runner configuration from `nx.json`.
+
+##### Before
+
+```json title="nx.json"
+{
+  "targetDefaults": {},
+  "tasksRunnerOptions": {
+    "default": {
+      "runner": "custom-task-runner"
+    }
+  }
+}
+```
+
+##### After
+
+```json title="nx.json"
+{
+  "targetDefaults": {}
+}
+```

package/dist/src/migrations/update-21-0-0/remove-legacy-cache.md

@@ -0,0 +1,22 @@
+#### Use Legacy Cache
+
+Removes `useLegacyCache` from `nx.json` as it is no longer functional in Nx 21
+
+#### Sample Code Changes
+
+##### Before
+
+```json title="nx.json"
+{
+  "targetDefaults": {},
+  "useLegacyCache": true
+}
+```
+
+##### After
+
+```json title="nx.json"
+{
+  "targetDefaults": {}
+}
+```

package/dist/src/migrations/update-22-2-0/add-self-healing-to-gitignore.md

@@ -0,0 +1,11 @@
+#### Add Self-Healing Directory to Git Ignore
+
+Add gitignore entry for the `.nx/self-healing` directory, which stores local fix context generated by Nx's self-healing CI feature.
+
+#### Sample Code Changes
+
+Adds the following entry to the `.gitignore` file.
+
+```text title=".gitignore"
+.nx/self-healing
+```

package/dist/src/migrations/update-23-0-0/add-migrate-runs-to-git-ignore.d.ts

@@ -0,0 +1,2 @@
+import { Tree } from '../../generators/tree';
+export default function addMigrateRunsToGitIgnore(tree: Tree): Promise<void>;

package/dist/src/migrations/update-23-0-0/add-migrate-runs-to-git-ignore.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = addMigrateRunsToGitIgnore;
+const format_changed_files_with_prettier_if_available_1 = require("../../generators/internal-utils/format-changed-files-with-prettier-if-available");
+const ignore_1 = require("../../utils/ignore");
+async function addMigrateRunsToGitIgnore(tree) {
+    if (!tree.exists('.gitignore')) {
+        return;
+    }
+    // Lerna users that don't use nx.json may not expect .nx directory changes
+    if (tree.exists('lerna.json') && !tree.exists('nx.json')) {
+        return;
+    }
+    (0, ignore_1.addEntryToGitIgnore)(tree, '.gitignore', '.nx/migrate-runs');
+    await (0, format_changed_files_with_prettier_if_available_1.formatChangedFilesWithPrettierIfAvailable)(tree);
+}

package/dist/src/migrations/update-23-0-0/consolidate-release-tag-config.d.ts

@@ -0,0 +1,9 @@
+import type { Tree } from '../../generators/tree';
+/**
+ * The deprecated releaseTag* flat properties were removed in Nx 23. Re-run the
+ * v22 consolidation for any workspaces that still have the legacy keys (e.g.,
+ * configs added manually after the v22 migration ran). Runs automatically as
+ * part of `nx migrate` and is also triggered by `nx repair` when the runtime
+ * detects legacy keys still present in `nx.json`.
+ */
+export default function (tree: Tree): Promise<void>;

package/dist/src/migrations/update-23-0-0/consolidate-release-tag-config.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = default_1;
+const tslib_1 = require("tslib");
+const consolidate_release_tag_config_1 = tslib_1.__importDefault(require("../update-22-0-0/consolidate-release-tag-config"));
+/**
+ * The deprecated releaseTag* flat properties were removed in Nx 23. Re-run the
+ * v22 consolidation for any workspaces that still have the legacy keys (e.g.,
+ * configs added manually after the v22 migration ran). Runs automatically as
+ * part of `nx migrate` and is also triggered by `nx repair` when the runtime
+ * detects legacy keys still present in `nx.json`.
+ */
+// TODO(v24): remove this migration (along with its registration in
+// migrations.json) and the LEGACY_RELEASE_TAG_PATTERN_PROPERTIES_DETECTED
+// runtime error path in packages/nx/src/command-line/release/config/config.ts.
+async function default_1(tree) {
+    return (0, consolidate_release_tag_config_1.default)(tree);
+}

package/dist/src/migrations/update-23-0-0/convert-target-defaults-to-array.d.ts

@@ -0,0 +1,35 @@
+import { Tree } from '../../generators/tree';
+import type { TargetDefaultEntry, TargetDefaultsRecord } from '../../config/nx-json';
+import type { ProjectGraph } from '../../config/project-graph';
+/**
+ * Converts the legacy record-shape `targetDefaults` in nx.json to the new
+ * array shape introduced in Nx 23. No-op when `targetDefaults` is absent
+ * or already an array.
+ *
+ * This is a pure shape conversion: every legacy key produces at least one
+ * array entry, nothing is ever dropped. A key that looks unused at
+ * migration time may still be a live default — the target can be added
+ * later, and the project graph at migration time can be incomplete.
+ *
+ * A project graph is built internally (and only when needed) to
+ * disambiguate `:`-style keys; see {@link convertTargetDefaultsRecordToArray}.
+ */
+export default function convertTargetDefaultsToArray(tree: Tree): Promise<string[]>;
+/**
+ * Pure conversion from the legacy record shape to the array shape.
+ *
+ * Kept separate from the migration entry point — and accepting the graph
+ * as an explicit argument — so the disambiguation logic can be unit tested
+ * directly with synthetic graphs. The migration runner never hands a
+ * migration a project graph, so this seam is what keeps that behaviour
+ * testable without standing up a real workspace.
+ *
+ * Disambiguation per key:
+ * - A glob, or a plain key with no `:`, is unambiguously a target name.
+ * - A `:` key is ambiguous (target name vs `pkg:executor` id). When the
+ *   graph shows it used as a target name, an executor, or both, the
+ *   matching entry/entries are emitted. With no graph signal, it falls
+ *   back to the syntactic heuristic (`:` → executor). Either way an entry
+ *   is always emitted.
+ */
+export declare function convertTargetDefaultsRecordToArray(legacy: TargetDefaultsRecord, graph?: ProjectGraph): TargetDefaultEntry[];

package/dist/src/migrations/update-23-0-0/convert-target-defaults-to-array.js

@@ -0,0 +1,139 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = convertTargetDefaultsToArray;
+exports.convertTargetDefaultsRecordToArray = convertTargetDefaultsRecordToArray;
+const format_changed_files_with_prettier_if_available_1 = require("../../generators/internal-utils/format-changed-files-with-prettier-if-available");
+const nx_json_1 = require("../../generators/utils/nx-json");
+const project_graph_1 = require("../../project-graph/project-graph");
+const globs_1 = require("../../utils/globs");
+/**
+ * Converts the legacy record-shape `targetDefaults` in nx.json to the new
+ * array shape introduced in Nx 23. No-op when `targetDefaults` is absent
+ * or already an array.
+ *
+ * This is a pure shape conversion: every legacy key produces at least one
+ * array entry, nothing is ever dropped. A key that looks unused at
+ * migration time may still be a live default — the target can be added
+ * later, and the project graph at migration time can be incomplete.
+ *
+ * A project graph is built internally (and only when needed) to
+ * disambiguate `:`-style keys; see {@link convertTargetDefaultsRecordToArray}.
+ */
+async function convertTargetDefaultsToArray(tree) {
+    if (!tree.exists('nx.json')) {
+        return [];
+    }
+    const nxJson = (0, nx_json_1.readNxJson)(tree);
+    if (!nxJson)
+        return [];
+    const { targetDefaults } = nxJson;
+    if (!targetDefaults)
+        return [];
+    if (Array.isArray(targetDefaults))
+        return [];
+    const legacy = targetDefaults;
+    const nextSteps = [];
+    // The graph is only consulted to disambiguate `:`-style keys (target name
+    // vs `pkg:executor` id). Skip building it entirely when there are none.
+    const graph = Object.keys(legacy).some(isExecutorAmbiguousKey)
+        ? await tryCreateProjectGraph(nextSteps)
+        : undefined;
+    nxJson.targetDefaults = convertTargetDefaultsRecordToArray(legacy, graph);
+    (0, nx_json_1.updateNxJson)(tree, nxJson);
+    await (0, format_changed_files_with_prettier_if_available_1.formatChangedFilesWithPrettierIfAvailable)(tree);
+    return nextSteps;
+}
+/**
+ * Pure conversion from the legacy record shape to the array shape.
+ *
+ * Kept separate from the migration entry point — and accepting the graph
+ * as an explicit argument — so the disambiguation logic can be unit tested
+ * directly with synthetic graphs. The migration runner never hands a
+ * migration a project graph, so this seam is what keeps that behaviour
+ * testable without standing up a real workspace.
+ *
+ * Disambiguation per key:
+ * - A glob, or a plain key with no `:`, is unambiguously a target name.
+ * - A `:` key is ambiguous (target name vs `pkg:executor` id). When the
+ *   graph shows it used as a target name, an executor, or both, the
+ *   matching entry/entries are emitted. With no graph signal, it falls
+ *   back to the syntactic heuristic (`:` → executor). Either way an entry
+ *   is always emitted.
+ */
+function convertTargetDefaultsRecordToArray(legacy, graph) {
+    const entries = [];
+    for (const key of Object.keys(legacy)) {
+        const value = legacy[key] ?? {};
+        entries.push(...legacyKeyToEntries(key, value, graph));
+    }
+    return entries;
+}
+/**
+ * A legacy record key is ambiguous between a target name and an executor
+ * id only when it contains `:` and is not a glob (executor ids are
+ * `pkg:name`; globs would also contain `*` / `{` / etc., which
+ * `isGlobPattern` catches). These are the only keys the graph helps with.
+ */
+function isExecutorAmbiguousKey(key) {
+    return key.includes(':') && !(0, globs_1.isGlobPattern)(key);
+}
+function legacyKeyToEntries(key, value, graph) {
+    // Globs and plain (no `:`) keys are unambiguously target names.
+    if (!isExecutorAmbiguousKey(key)) {
+        return [{ target: key, ...value }];
+    }
+    // A `:` key could be a target name or a `pkg:executor` id. Use the graph
+    // to disambiguate when it has something to say.
+    if (graph) {
+        const { matchesTargetName, matchesExecutor } = classifyKeyAgainstGraph(key, graph);
+        if (matchesTargetName && matchesExecutor) {
+            return [
+                { target: key, ...value },
+                { executor: key, ...value },
+            ];
+        }
+        if (matchesTargetName)
+            return [{ target: key, ...value }];
+        if (matchesExecutor)
+            return [{ executor: key, ...value }];
+        // Graph had no signal for this key — fall through to the syntactic
+        // heuristic rather than dropping the entry.
+    }
+    // Syntactic fallback: a `:` key that is not a glob is an executor id.
+    return [{ executor: key, ...value }];
+}
+function classifyKeyAgainstGraph(key, graph) {
+    let matchesTargetName = false;
+    let matchesExecutor = false;
+    for (const node of Object.values(graph.nodes ?? {})) {
+        const targets = node?.data?.targets;
+        if (!targets)
+            continue;
+        for (const [name, target] of Object.entries(targets)) {
+            if (!matchesTargetName && name === key)
+                matchesTargetName = true;
+            if (!matchesExecutor && target?.executor === key)
+                matchesExecutor = true;
+            if (matchesTargetName && matchesExecutor) {
+                return { matchesTargetName, matchesExecutor };
+            }
+        }
+    }
+    return { matchesTargetName, matchesExecutor };
+}
+async function tryCreateProjectGraph(nextSteps) {
+    // Build fresh — earlier migrations in this run may have mutated files
+    // the cached graph was computed from, so a cache hit could classify
+    // record keys against a stale workspace.
+    try {
+        return await (0, project_graph_1.createProjectGraphAsync)();
+    }
+    catch (err) {
+        nextSteps.push('convert-target-defaults-to-array: project graph could not be built; ' +
+            'falling back to syntactic disambiguation for `:` keys in nx.json `targetDefaults`. ' +
+            'If a key happens to match both a target name and an executor in your workspace, ' +
+            'review the migration result and add the missing entry by hand. ' +
+            `Underlying error: ${err instanceof Error ? err.message : String(err)}`);
+        return undefined;
+    }
+}

package/dist/src/migrations/update-23-0-0/convert-target-defaults-to-array.md

@@ -0,0 +1,66 @@
+#### Convert `targetDefaults` to Array Shape
+
+In Nx v23, the `targetDefaults` entry in `nx.json` moves from the legacy record (object-keyed) shape to a new array shape. The array shape lets a single default match by `target`, `executor`, `plugin`, or `projects` — combinations that the record key could not express on its own.
+
+This migration is a pure shape conversion: every legacy key produces at least one array entry, and nothing is ever dropped. The order of entries in the resulting array matches the insertion order of the original record keys.
+
+#### Key Disambiguation
+
+The legacy record key could mean either a target name (`build`) or a `pkg:executor` id (`@nx/vite:build`). The new array shape requires that distinction up front, so the migration disambiguates each key as follows:
+
+- A glob pattern (e.g. `e2e-ci--*`) or a plain key without `:` is always treated as a `target` name.
+- A `:` key is ambiguous. The migration builds the project graph and emits:
+  - `{ target: <key> }` if the key matches only a target name in the graph,
+  - `{ executor: <key> }` if it matches only an executor,
+  - **both** entries if it matches both (the graph cannot tell you which one you meant — keeping both preserves behavior).
+- If the project graph cannot be built, or has no signal for a `:` key, the migration falls back to the syntactic heuristic: `:` keys become `executor` entries. A note is added to the migration's next steps so you can review.
+
+#### Sample Code Changes
+
+##### Before
+
+```json title="nx.json"
+{
+  "targetDefaults": {
+    "build": {
+      "cache": true,
+      "dependsOn": ["^build"]
+    },
+    "test": {
+      "inputs": ["default", "^production"]
+    },
+    "e2e-ci--*": {
+      "dependsOn": ["^build"]
+    },
+    "@nx/vite:build": {
+      "cache": true
+    }
+  }
+}
+```
+
+##### After
+
+```json title="nx.json"
+{
+  "targetDefaults": [
+    {
+      "target": "build",
+      "cache": true,
+      "dependsOn": ["^build"]
+    },
+    {
+      "target": "test",
+      "inputs": ["default", "^production"]
+    },
+    {
+      "target": "e2e-ci--*",
+      "dependsOn": ["^build"]
+    },
+    {
+      "executor": "@nx/vite:build",
+      "cache": true
+    }
+  ]
+}
+```