nx 21.3.0-canary.20250627-07233f0 → 21.3.0-canary.20250628-7430238

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nx",
-  "version": "21.3.0-canary.20250627-07233f0",
+  "version": "21.3.0-canary.20250628-7430238",
   "private": false,
   "description": "The core Nx plugin contains the core functionality of Nx like the project graph, nx commands and task orchestration.",
   "repository": {
@@ -83,16 +83,16 @@
     }
   },
   "optionalDependencies": {
-    "@nx/nx-darwin-arm64": "21.3.0-canary.20250627-07233f0",
-    "@nx/nx-darwin-x64": "21.3.0-canary.20250627-07233f0",
-    "@nx/nx-freebsd-x64": "21.3.0-canary.20250627-07233f0",
-    "@nx/nx-linux-arm-gnueabihf": "21.3.0-canary.20250627-07233f0",
-    "@nx/nx-linux-arm64-gnu": "21.3.0-canary.20250627-07233f0",
-    "@nx/nx-linux-arm64-musl": "21.3.0-canary.20250627-07233f0",
-    "@nx/nx-linux-x64-gnu": "21.3.0-canary.20250627-07233f0",
-    "@nx/nx-linux-x64-musl": "21.3.0-canary.20250627-07233f0",
-    "@nx/nx-win32-arm64-msvc": "21.3.0-canary.20250627-07233f0",
-    "@nx/nx-win32-x64-msvc": "21.3.0-canary.20250627-07233f0"
+    "@nx/nx-darwin-arm64": "21.3.0-canary.20250628-7430238",
+    "@nx/nx-darwin-x64": "21.3.0-canary.20250628-7430238",
+    "@nx/nx-freebsd-x64": "21.3.0-canary.20250628-7430238",
+    "@nx/nx-linux-arm-gnueabihf": "21.3.0-canary.20250628-7430238",
+    "@nx/nx-linux-arm64-gnu": "21.3.0-canary.20250628-7430238",
+    "@nx/nx-linux-arm64-musl": "21.3.0-canary.20250628-7430238",
+    "@nx/nx-linux-x64-gnu": "21.3.0-canary.20250628-7430238",
+    "@nx/nx-linux-x64-musl": "21.3.0-canary.20250628-7430238",
+    "@nx/nx-win32-arm64-msvc": "21.3.0-canary.20250628-7430238",
+    "@nx/nx-win32-x64-msvc": "21.3.0-canary.20250628-7430238"
   },
   "nx-migrations": {
     "migrations": "./migrations.json",

package/src/adapter/ngcli-adapter.d.ts

@@ -87,4 +87,15 @@ export declare function wrapAngularDevkitSchematic(collectionName: string, gener
     [k: string]: any;
 }) => Promise<GeneratorCallback>;
 export declare const getLogger: (isVerbose?: boolean) => logging.Logger;
+/**
+ * Restores Nx tokens in options when possible by comparing new and previous
+ * options.
+ * The function preserves tokens in the following cases:
+ * 1. When the resolved previous value matches the new value exactly
+ * 2. When the previous value used {workspaceRoot}
+ * 3. When the previous value used {projectRoot} and the new value starts with
+ *    the project root path
+ * Those are the only safe cases, for all other cases, the new value is used as-is.
+ */
+export declare function restoreNxTokensInOptions<T extends Object | Array<unknown>>(newOptions: T, previousOptions: T, project: ProjectConfiguration): T;
 export {};

package/src/adapter/ngcli-adapter.js

@@ -8,6 +8,7 @@ exports.generate = generate;
 exports.runMigration = runMigration;
 exports.mockSchematicsForTesting = mockSchematicsForTesting;
 exports.wrapAngularDevkitSchematic = wrapAngularDevkitSchematic;
+exports.restoreNxTokensInOptions = restoreNxTokensInOptions;
 const core_1 = require("@angular-devkit/core");
 const node_1 = require("@angular-devkit/core/node");
 const chalk = require("chalk");
@@ -28,6 +29,7 @@ const angular_json_1 = require("./angular-json");
 const executor_utils_1 = require("../command-line/run/executor-utils");
 const plugins_1 = require("../project-graph/plugins");
 const schema_utils_1 = require("../config/schema-utils");
+const project_configuration_utils_1 = require("../project-graph/utils/project-configuration-utils");
 async function createBuilderContext(builderInfo, context) {
     require('./compat');
     const fsHost = new NxScopedHostForBuilders(context.root);
@@ -296,10 +298,32 @@ class NxScopedHost extends core_1.virtualFs.ScopedHost {
                 const projects = configV2.projects;
                 const allObservables = [];
                 Object.keys(projects).forEach((projectName) => {
-                    if (projectsInAngularJson.includes(projectName)) {
-                        // ignore updates to angular.json
-                    }
-                    else {
+                    if (!projectsInAngularJson.includes(projectName)) {
+                        // Restore tokens in options if they were present before
+                        const previousProject = existingConfig.projects[projectName];
+                        const newProject = projects[projectName];
+                        if (previousProject &&
+                            newProject.targets &&
+                            previousProject.targets) {
+                            for (const [targetName, target] of Object.entries(newProject.targets)) {
+                                const previousTarget = previousProject.targets[targetName];
+                                if (target.options &&
+                                    previousTarget &&
+                                    previousTarget.options) {
+                                    target.options = restoreNxTokensInOptions(target.options, previousTarget.options, newProject);
+                                }
+                                if (target.configurations &&
+                                    previousTarget &&
+                                    previousTarget.configurations) {
+                                    for (const [configName, config] of Object.entries(target.configurations)) {
+                                        if (previousTarget.configurations[configName]) {
+                                            target.configurations[configName] =
+                                                restoreNxTokensInOptions(config, previousTarget.configurations[configName], newProject);
+                                        }
+                                    }
+                                }
+                            }
+                        }
                         (0, project_configuration_1.updateProjectConfiguration)({
                             root,
                             exists: () => true,
@@ -430,9 +454,23 @@ class NxScopeHostUsedForWrappedSchematics extends NxScopedHost {
     read(path) {
         if ((path === 'angular.json' || path === '/angular.json') &&
             (0, angular_json_1.isAngularPluginInstalled)()) {
-            const projectJsonConfig = (0, angular_json_1.toOldFormat)({
-                projects: Object.fromEntries((0, project_configuration_1.getProjects)(this.host)),
-            });
+            // Replace the Nx-specific tokens in all target options
+            const projects = Object.fromEntries((0, project_configuration_1.getProjects)(this.host));
+            for (const [projectName, project] of Object.entries(projects)) {
+                if (project.targets) {
+                    for (const [targetName, target] of Object.entries(project.targets)) {
+                        if (target.options) {
+                            target.options = (0, project_configuration_utils_1.resolveNxTokensInOptions)(target.options, { ...project, name: projectName }, `${projectName}:${targetName}`);
+                        }
+                        if (target.configurations) {
+                            for (const [configName, config] of Object.entries(target.configurations)) {
+                                target.configurations[configName] = (0, project_configuration_utils_1.resolveNxTokensInOptions)(config, { ...project, name: projectName }, `${projectName}:${targetName}:${configName}`);
+                            }
+                        }
+                    }
+                }
+            }
+            const projectJsonConfig = (0, angular_json_1.toOldFormat)({ projects });
             return super.readExistingAngularJson().pipe((0, operators_1.map)((angularJson) => {
                 if (angularJson) {
                     return Buffer.from(JSON.stringify({
@@ -852,3 +890,59 @@ async function getWrappedWorkspaceNodeModulesArchitectHost(workspace, root, proj
     }
     return new WrappedWorkspaceNodeModulesArchitectHost(workspace, root, projects);
 }
+/**
+ * Restores Nx tokens in options when possible by comparing new and previous
+ * options.
+ * The function preserves tokens in the following cases:
+ * 1. When the resolved previous value matches the new value exactly
+ * 2. When the previous value used {workspaceRoot}
+ * 3. When the previous value used {projectRoot} and the new value starts with
+ *    the project root path
+ * Those are the only safe cases, for all other cases, the new value is used as-is.
+ */
+function restoreNxTokensInOptions(newOptions, previousOptions, project) {
+    if (!newOptions || !previousOptions) {
+        return newOptions;
+    }
+    const result = Array.isArray(newOptions)
+        ? [...newOptions]
+        : { ...newOptions };
+    const resolvedPreviousOptions = (0, project_configuration_utils_1.resolveNxTokensInOptions)(previousOptions, project, '');
+    for (const key of Object.keys(newOptions)) {
+        const newValue = newOptions[key];
+        const previousValue = previousOptions[key];
+        if (typeof newValue === 'string' && typeof previousValue === 'string') {
+            if (resolvedPreviousOptions[key] === newValue) {
+                // If the resolved previous value matches the new value, use the previous
+                // value (potentially with tokens)
+                result[key] = previousValue;
+            }
+            else if (previousValue.startsWith('{workspaceRoot}/')) {
+                // If the previous value started with {workspaceRoot}, prefix the new
+                // value with {workspaceRoot}
+                result[key] = `{workspaceRoot}/${newValue.replace(/^\//, '')}`;
+            }
+            else if (previousValue.startsWith('{projectRoot}/') &&
+                newValue.startsWith(`${project.root}/`)) {
+                // If the previous value started with {projectRoot} and the new value
+                // starts with the project root, replace the project root with the
+                // {projectRoot} token
+                result[key] = newValue.replace(`${project.root}/`, '{projectRoot}/');
+            }
+            else {
+                // Otherwise, use the new value as-is
+                result[key] = newValue;
+            }
+        }
+        else if (typeof newValue === 'object' &&
+            typeof previousValue === 'object' &&
+            newValue &&
+            previousValue) {
+            result[key] = restoreNxTokensInOptions(newValue, previousValue, project);
+        }
+        else {
+            result[key] = newValue;
+        }
+    }
+    return result;
+}

package/src/plugins/js/lock-file/lock-file.js

@@ -191,6 +191,7 @@ function createLockFile(packageJson, graph, packageManager = (0, package_manager
             output_1.output.log({
                 title: "Unable to create bun lock files. Run bun install it's just as quick",
             });
+            return '';
         }
     }
     catch (e) {

package/src/utils/package-json.js

@@ -124,7 +124,7 @@ function readTargetsFromPackageJson(packageJson, nxJson, projectRoot, workspaceR
 function hasNxJsPlugin(projectRoot, workspaceRoot) {
     try {
         // nx-ignore-next-line
-        require.resolve('@nx/js', {
+        require.resolve('@nx/js/package.json', {
             paths: [projectRoot, ...(0, installation_directory_1.getNxRequirePaths)(workspaceRoot), __dirname],
         });
         return true;