nx 21.2.1 → 21.2.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nx",
-  "version": "21.2.1",
+  "version": "21.2.2",
   "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.2.1",
-    "@nx/nx-darwin-x64": "21.2.1",
-    "@nx/nx-freebsd-x64": "21.2.1",
-    "@nx/nx-linux-arm-gnueabihf": "21.2.1",
-    "@nx/nx-linux-arm64-gnu": "21.2.1",
-    "@nx/nx-linux-arm64-musl": "21.2.1",
-    "@nx/nx-linux-x64-gnu": "21.2.1",
-    "@nx/nx-linux-x64-musl": "21.2.1",
-    "@nx/nx-win32-arm64-msvc": "21.2.1",
-    "@nx/nx-win32-x64-msvc": "21.2.1"
+    "@nx/nx-darwin-arm64": "21.2.2",
+    "@nx/nx-darwin-x64": "21.2.2",
+    "@nx/nx-freebsd-x64": "21.2.2",
+    "@nx/nx-linux-arm-gnueabihf": "21.2.2",
+    "@nx/nx-linux-arm64-gnu": "21.2.2",
+    "@nx/nx-linux-arm64-musl": "21.2.2",
+    "@nx/nx-linux-x64-gnu": "21.2.2",
+    "@nx/nx-linux-x64-musl": "21.2.2",
+    "@nx/nx-win32-arm64-msvc": "21.2.2",
+    "@nx/nx-win32-x64-msvc": "21.2.2"
   },
   "nx-migrations": {
     "migrations": "./migrations.json",

package/src/adapter/decorate-cli.js

@@ -1,11 +1,12 @@
 "use strict";
+// TODO(v22): remove this file
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.decorateCli = decorateCli;
 const fs_1 = require("fs");
 const output_1 = require("../utils/output");
 function decorateCli() {
     output_1.output.warn({
-        title: `Decoration of the Angular CLI is deprecated and will be removed in a future version`,
+        title: `Decoration of the Angular CLI is deprecated and will be removed in Nx v22`,
         bodyLines: [
             `Please replace usage of "ng <command>" in any scripts, particularly for CI, with "nx <command>"`,
         ],

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/command-line/migrate/migrate-ui-api.d.ts

@@ -1,7 +1,7 @@
 import type { MigrationDetailsWithId } from '../../config/misc-interfaces';
 import type { FileChange } from '../../generators/tree';
 export type MigrationsJsonMetadata = {
-    completedMigrations?: Record<string, SuccessfulMigration | FailedMigration | SkippedMigration>;
+    completedMigrations?: Record<string, SuccessfulMigration | FailedMigration | SkippedMigration | StoppedMigration>;
     runningMigrations?: string[];
     initialGitRef?: {
         ref: string;
@@ -25,6 +25,11 @@ export type FailedMigration = {
 export type SkippedMigration = {
     type: 'skipped';
 };
+export type StoppedMigration = {
+    type: 'stopped';
+    name: string;
+    error: string;
+};
 export declare function recordInitialMigrationMetadata(workspacePath: string, versionToMigrateTo: string): void;
 export declare function finishMigrationProcess(workspacePath: string, squashCommits: boolean, commitMessage: string): void;
 export declare function runSingleMigration(workspacePath: string, migration: MigrationDetailsWithId, configuration: {
@@ -36,7 +41,7 @@ export declare function modifyMigrationsJsonMetadata(workspacePath: string, modi
 export declare function addSuccessfulMigration(id: string, fileChanges: Omit<FileChange, 'content'>[], ref: string, nextSteps: string[]): (migrationsJsonMetadata: MigrationsJsonMetadata) => MigrationsJsonMetadata;
 export declare function updateRefForSuccessfulMigration(id: string, ref: string): (migrationsJsonMetadata: MigrationsJsonMetadata) => MigrationsJsonMetadata;
 export declare function addFailedMigration(id: string, error: string): (migrationsJsonMetadata: MigrationsJsonMetadata) => {
-    completedMigrations?: Record<string, SuccessfulMigration | FailedMigration | SkippedMigration>;
+    completedMigrations?: Record<string, SuccessfulMigration | FailedMigration | SkippedMigration | StoppedMigration>;
     runningMigrations?: string[];
     initialGitRef?: {
         ref: string;
@@ -46,7 +51,17 @@ export declare function addFailedMigration(id: string, error: string): (migratio
     targetVersion?: string;
 };
 export declare function addSkippedMigration(id: string): (migrationsJsonMetadata: MigrationsJsonMetadata) => {
-    completedMigrations?: Record<string, SuccessfulMigration | FailedMigration | SkippedMigration>;
+    completedMigrations?: Record<string, SuccessfulMigration | FailedMigration | SkippedMigration | StoppedMigration>;
+    runningMigrations?: string[];
+    initialGitRef?: {
+        ref: string;
+        subject: string;
+    };
+    confirmedPackageUpdates?: boolean;
+    targetVersion?: string;
+};
+export declare function addStoppedMigration(id: string, error: string): (migrationsJsonMetadata: MigrationsJsonMetadata) => {
+    completedMigrations?: Record<string, SuccessfulMigration | FailedMigration | SkippedMigration | StoppedMigration>;
     runningMigrations?: string[];
     initialGitRef?: {
         ref: string;
@@ -57,3 +72,5 @@ export declare function addSkippedMigration(id: string): (migrationsJsonMetadata
 };
 export declare function readMigrationsJsonMetadata(workspacePath: string): MigrationsJsonMetadata;
 export declare function undoMigration(workspacePath: string, id: string): (migrationsJsonMetadata: MigrationsJsonMetadata) => MigrationsJsonMetadata;
+export declare function killMigrationProcess(migrationId: string, workspacePath?: string): boolean;
+export declare function stopMigration(migrationId: string): (migrationsJsonMetadata: MigrationsJsonMetadata) => MigrationsJsonMetadata;

package/src/command-line/migrate/migrate-ui-api.js

@@ -9,12 +9,18 @@ exports.addSuccessfulMigration = addSuccessfulMigration;
 exports.updateRefForSuccessfulMigration = updateRefForSuccessfulMigration;
 exports.addFailedMigration = addFailedMigration;
 exports.addSkippedMigration = addSkippedMigration;
+exports.addStoppedMigration = addStoppedMigration;
 exports.readMigrationsJsonMetadata = readMigrationsJsonMetadata;
 exports.undoMigration = undoMigration;
+exports.killMigrationProcess = killMigrationProcess;
+exports.stopMigration = stopMigration;
 const child_process_1 = require("child_process");
 const fs_1 = require("fs");
 const path_1 = require("path");
 const migrate_1 = require("./migrate");
+let currentMigrationProcess = null;
+let currentMigrationId = null;
+let migrationCancelled = false;
 function recordInitialMigrationMetadata(workspacePath, versionToMigrateTo) {
     const migrationsJsonPath = (0, path_1.join)(workspacePath, 'migrations.json');
     const parsedMigrationsJson = JSON.parse((0, fs_1.readFileSync)(migrationsJsonPath, 'utf-8'));
@@ -63,20 +69,62 @@ function finishMigrationProcess(workspacePath, squashCommits, commitMessage) {
 }
 async function runSingleMigration(workspacePath, migration, configuration) {
     try {
+        // Set current migration tracking
+        currentMigrationId = migration.id;
+        migrationCancelled = false;
         modifyMigrationsJsonMetadata(workspacePath, addRunningMigration(migration.id));
         const gitRefBefore = (0, child_process_1.execSync)('git rev-parse HEAD', {
             cwd: workspacePath,
             encoding: 'utf-8',
         }).trim();
-        // For Migrate UI, this current module is loaded either from:
-        // 1. The CLI path to the migrated modules. The version of Nx is of the user's choosing. This may or may not have the new migrate API, so Console will check that `runSingleMigration` exists before using it.
-        // 2. Bundled into Console, so the version is fixed to what we build Console with.
-        const updatedMigrateModule = await Promise.resolve().then(() => require('./migrate.js'));
-        const { changes: fileChanges, nextSteps } = await updatedMigrateModule.runNxOrAngularMigration(workspacePath, migration, false, configuration.createCommits, configuration.commitPrefix || 'chore: [nx migration] ', undefined, true);
-        const gitRefAfter = (0, child_process_1.execSync)('git rev-parse HEAD', {
+        // Run migration in a separate process so it can be cancelled
+        const runMigrationProcessPath = require.resolve('./run-migration-process.js');
+        const migrationProcess = (0, child_process_1.spawn)('node', [
+            runMigrationProcessPath,
+            workspacePath,
+            migration.id,
+            migration.package,
+            migration.name,
+            migration.version,
+            configuration.createCommits.toString(),
+            configuration.commitPrefix || 'chore: [nx migration] ',
+        ], {
             cwd: workspacePath,
-            encoding: 'utf-8',
-        }).trim();
+            stdio: ['pipe', 'pipe', 'pipe'],
+        });
+        // Track the process for cancellation
+        currentMigrationProcess = migrationProcess;
+        // Handle process output
+        let output = '';
+        migrationProcess.stdout.on('data', (data) => {
+            output += data.toString();
+        });
+        migrationProcess.stderr.on('data', (data) => {
+            console.error('Migration stderr:', data.toString());
+        });
+        // Wait for the process to complete
+        const exitCode = await new Promise((resolve, reject) => {
+            migrationProcess.on('close', (code) => {
+                resolve(code);
+            });
+            migrationProcess.on('error', (error) => {
+                reject(error);
+            });
+        });
+        currentMigrationProcess = null;
+        if (exitCode !== 0) {
+            throw new Error(`Migration process exited with code ${exitCode}`);
+        }
+        // Parse the result from the migration process (extract the JSON output)
+        const jsonStr = output
+            .trim()
+            .split('\n')
+            .find((line) => line.startsWith('{'));
+        const result = JSON.parse(jsonStr);
+        if (result.type === 'error') {
+            throw new Error(result.message);
+        }
+        const { fileChanges, gitRefAfter, nextSteps } = result;
         modifyMigrationsJsonMetadata(workspacePath, addSuccessfulMigration(migration.id, fileChanges.map((change) => ({
             path: change.path,
             type: change.type,
@@ -99,9 +147,21 @@ async function runSingleMigration(workspacePath, migration, configuration) {
         }
     }
     catch (e) {
-        modifyMigrationsJsonMetadata(workspacePath, addFailedMigration(migration.id, e.message));
+        // Check if migration was cancelled/stopped
+        if (migrationCancelled && currentMigrationId === migration.id) {
+            // Migration was stopped by user, don't add as failed since it's already marked as stopped
+            console.log(`Migration ${migration.id} was stopped by user`);
+        }
+        else {
+            // Migration failed normally
+            modifyMigrationsJsonMetadata(workspacePath, addFailedMigration(migration.id, e.message));
+        }
     }
     finally {
+        // Clear the tracking variables
+        currentMigrationProcess = null;
+        currentMigrationId = null;
+        migrationCancelled = false;
         modifyMigrationsJsonMetadata(workspacePath, removeRunningMigration(migration.id));
         (0, child_process_1.execSync)('git add migrations.json', {
             cwd: workspacePath,
@@ -187,6 +247,23 @@ function addSkippedMigration(id) {
         return copied;
     };
 }
+function addStoppedMigration(id, error) {
+    return (migrationsJsonMetadata) => {
+        const copied = { ...migrationsJsonMetadata };
+        if (!copied.completedMigrations) {
+            copied.completedMigrations = {};
+        }
+        copied.completedMigrations = {
+            ...copied.completedMigrations,
+            [id]: {
+                type: 'stopped',
+                name: id,
+                error,
+            },
+        };
+        return copied;
+    };
+}
 function addRunningMigration(id) {
     return (migrationsJsonMetadata) => {
         migrationsJsonMetadata.runningMigrations = [
@@ -200,9 +277,6 @@ function removeRunningMigration(id) {
     return (migrationsJsonMetadata) => {
         migrationsJsonMetadata.runningMigrations =
             migrationsJsonMetadata.runningMigrations?.filter((n) => n !== id);
-        if (migrationsJsonMetadata.runningMigrations?.length === 0) {
-            delete migrationsJsonMetadata.runningMigrations;
-        }
         return migrationsJsonMetadata;
     };
 }
@@ -226,3 +300,32 @@ function undoMigration(workspacePath, id) {
         return migrationsJsonMetadata;
     };
 }
+function killMigrationProcess(migrationId, workspacePath) {
+    try {
+        if (workspacePath) {
+            modifyMigrationsJsonMetadata(workspacePath, stopMigration(migrationId));
+        }
+        // Check if this is the currently running migration and kill the process
+        if (currentMigrationId === migrationId && currentMigrationProcess) {
+            currentMigrationProcess.kill('SIGTERM');
+            // Some processes may not respond to SIGTERM immediately,
+            // so we give it a short timeout before forcefully killing it
+            setTimeout(() => {
+                if (currentMigrationProcess && !currentMigrationProcess.killed) {
+                    currentMigrationProcess.kill('SIGKILL');
+                }
+            }, 2000);
+        }
+        return true;
+    }
+    catch (error) {
+        console.error(`Failed to stop migration ${migrationId}:`, error);
+        return false;
+    }
+}
+function stopMigration(migrationId) {
+    return (migrationsJsonMetadata) => {
+        const updated = addStoppedMigration(migrationId, 'Migration was stopped by user')(migrationsJsonMetadata);
+        return removeRunningMigration(migrationId)(updated);
+    };
+}

package/src/command-line/migrate/run-migration-process.js

@@ -0,0 +1,85 @@
+const { runNxOrAngularMigration } = require('./migrate');
+const { execSync } = require('child_process');
+
+async function runMigrationProcess() {
+  const [
+    ,
+    ,
+    workspacePath,
+    migrationId,
+    migrationPackage,
+    migrationName,
+    migrationVersion,
+    createCommits,
+    commitPrefix,
+  ] = process.argv;
+
+  const migration = {
+    id: migrationId,
+    package: migrationPackage,
+    name: migrationName,
+    version: migrationVersion,
+  };
+
+  const configuration = {
+    createCommits: createCommits === 'true',
+    commitPrefix: commitPrefix || 'chore: [nx migration] ',
+  };
+
+  try {
+    const gitRefBefore = execSync('git rev-parse HEAD', {
+      cwd: workspacePath,
+      encoding: 'utf-8',
+    }).trim();
+
+    const { changes: fileChanges, nextSteps } = await runNxOrAngularMigration(
+      workspacePath,
+      migration,
+      false,
+      configuration.createCommits,
+      configuration.commitPrefix,
+      undefined,
+      true
+    );
+
+    const gitRefAfter = execSync('git rev-parse HEAD', {
+      cwd: workspacePath,
+      encoding: 'utf-8',
+    }).trim();
+
+    // Report success
+    process.stdout.write(
+      JSON.stringify({
+        type: 'success',
+        fileChanges: fileChanges.map((change) => ({
+          path: change.path,
+          type: change.type,
+        })),
+        gitRefAfter,
+        nextSteps,
+      })
+    );
+
+    process.exit(0);
+  } catch (error) {
+    // Report failure
+    process.stdout.write(
+      JSON.stringify({
+        type: 'error',
+        message: error.message,
+      })
+    );
+
+    process.exit(1);
+  }
+}
+
+runMigrationProcess().catch((error) => {
+  process.stdout.write(
+    JSON.stringify({
+      type: 'error',
+      message: error.message,
+    })
+  );
+  process.exit(1);
+});