nx 21.0.0-beta.7 → 21.0.0-beta.9

package/src/project-graph/utils/project-configuration-utils.d.ts

@@ -66,9 +66,9 @@ export declare function isCompatibleTarget(a: TargetConfiguration, b: TargetConf
 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];
 /**
- * Expand's `command` syntactic sugar and replaces tokens in options.
+ * Expand's `command` syntactic sugar, replaces tokens in options, and adds information from executor schema.
  * @param target The target to normalize
  * @param project The project that the target belongs to
  * @returns The normalized target configuration
  */
-export declare function normalizeTarget(target: TargetConfiguration, project: ProjectConfiguration): TargetConfiguration<any>;
+export declare function normalizeTarget(target: TargetConfiguration, project: ProjectConfiguration, workspaceRoot: string, projectsMap: Record<string, ProjectConfiguration>): TargetConfiguration<any>;

package/src/project-graph/utils/project-configuration-utils.js

@@ -21,6 +21,7 @@ const perf_hooks_1 = require("perf_hooks");
 const error_types_1 = require("../error-types");
 const globs_1 = require("../../utils/globs");
 const delayed_spinner_1 = require("../../utils/delayed-spinner");
+const executor_utils_1 = require("../../command-line/run/executor-utils");
 function mergeProjectConfigurationIntoRootMap(projectRootMap, project, configurationSourceMaps, sourceInformation, 
 // This function is used when reading project configuration
 // in generators, where we don't want to do this.
@@ -294,7 +295,7 @@ plugins) {
     }
     return Promise.all(results).then((results) => {
         spinner?.cleanup();
-        const { projectRootMap, externalNodes, rootMap, configurationSourceMaps } = mergeCreateNodesResults(results, nxJson, errors);
+        const { projectRootMap, externalNodes, rootMap, configurationSourceMaps } = mergeCreateNodesResults(results, nxJson, root, errors);
         perf_hooks_1.performance.mark('build-project-configs:end');
         perf_hooks_1.performance.measure('build-project-configs', 'build-project-configs:start', 'build-project-configs:end');
         if (errors.length === 0) {
@@ -317,7 +318,7 @@ plugins) {
         }
     });
 }
-function mergeCreateNodesResults(results, nxJsonConfiguration, errors) {
+function mergeCreateNodesResults(results, nxJsonConfiguration, workspaceRoot, errors) {
     perf_hooks_1.performance.mark('createNodes:merge - start');
     const projectRootMap = {};
     const externalNodes = {};
@@ -350,7 +351,7 @@ function mergeCreateNodesResults(results, nxJsonConfiguration, errors) {
         Object.assign(externalNodes, pluginExternalNodes);
     }
     try {
-        validateAndNormalizeProjectRootMap(projectRootMap, nxJsonConfiguration, configurationSourceMaps);
+        validateAndNormalizeProjectRootMap(workspaceRoot, projectRootMap, nxJsonConfiguration, configurationSourceMaps);
     }
     catch (e) {
         if ((0, error_types_1.isProjectsWithNoNameError)(e) ||
@@ -428,7 +429,7 @@ function readProjectConfigurationsFromRootMap(projectRootMap) {
     }
     return projects;
 }
-function validateAndNormalizeProjectRootMap(projectRootMap, nxJsonConfiguration, sourceMaps = {}) {
+function validateAndNormalizeProjectRootMap(workspaceRoot, projectRootMap, nxJsonConfiguration, sourceMaps = {}) {
     // Name -> Project, used to validate that all projects have unique names
     const projects = {};
     // If there are projects that have the same name, that is an error.
@@ -461,7 +462,7 @@ function validateAndNormalizeProjectRootMap(projectRootMap, nxJsonConfiguration,
                 throw e;
             }
         }
-        normalizeTargets(project, sourceMaps, nxJsonConfiguration);
+        normalizeTargets(project, sourceMaps, nxJsonConfiguration, workspaceRoot, projects);
     }
     if (conflicts.size > 0) {
         throw new error_types_1.MultipleProjectsWithSameNameError(conflicts, projects);
@@ -471,15 +472,19 @@ function validateAndNormalizeProjectRootMap(projectRootMap, nxJsonConfiguration,
     }
     return projectRootMap;
 }
-function normalizeTargets(project, sourceMaps, nxJsonConfiguration) {
+function normalizeTargets(project, sourceMaps, nxJsonConfiguration, workspaceRoot, 
+/**
+ * Project configurations keyed by project name
+ */
+projects) {
     for (const targetName in project.targets) {
-        project.targets[targetName] = normalizeTarget(project.targets[targetName], project);
+        project.targets[targetName] = normalizeTarget(project.targets[targetName], project, workspaceRoot, projects);
         const projectSourceMaps = sourceMaps[project.root];
         const targetConfig = project.targets[targetName];
         const targetDefaults = deepClone(readTargetDefaultsForTarget(targetName, nxJsonConfiguration.targetDefaults, targetConfig.executor));
         // We only apply defaults if they exist
         if (targetDefaults && isCompatibleTarget(targetConfig, targetDefaults)) {
-            project.targets[targetName] = mergeTargetDefaultWithTargetDefinition(targetName, project, normalizeTarget(targetDefaults, project), projectSourceMaps);
+            project.targets[targetName] = mergeTargetDefaultWithTargetDefinition(targetName, project, normalizeTarget(targetDefaults, project, workspaceRoot, projects), projectSourceMaps);
         }
         if (
         // If the target has no executor or command, it doesn't do anything
@@ -789,12 +794,12 @@ function resolveCommandSyntacticSugar(target, key) {
     }
 }
 /**
- * Expand's `command` syntactic sugar and replaces tokens in options.
+ * Expand's `command` syntactic sugar, replaces tokens in options, and adds information from executor schema.
  * @param target The target to normalize
  * @param project The project that the target belongs to
  * @returns The normalized target configuration
  */
-function normalizeTarget(target, project) {
+function normalizeTarget(target, project, workspaceRoot, projectsMap) {
     target = {
         ...target,
         configurations: {
@@ -807,5 +812,19 @@ function normalizeTarget(target, project) {
         target.configurations[configuration] = resolveNxTokensInOptions(target.configurations[configuration], project, `${project.root}:${target}:${configuration}`);
     }
     target.parallelism ??= true;
+    if (target.executor && !('continuous' in target)) {
+        try {
+            const [executorNodeModule, executorName] = (0, executor_utils_1.parseExecutor)(target.executor);
+            const { schema } = (0, executor_utils_1.getExecutorInformation)(executorNodeModule, executorName, workspaceRoot, projectsMap);
+            if (schema.continuous) {
+                target.continuous ??= schema.continuous;
+            }
+        }
+        catch (e) {
+            // If the executor is not found, we assume that it is not a valid executor.
+            // This means that we should not set the continuous property.
+            // We could throw an error here, but it would be better to just ignore it.
+        }
+    }
     return target;
 }

package/src/tasks-runner/batch/run-batch.js

@@ -8,7 +8,7 @@ const configuration_1 = require("../../config/configuration");
 const async_iterator_1 = require("../../utils/async-iterator");
 const executor_utils_1 = require("../../command-line/run/executor-utils");
 function getBatchExecutor(executorName, projects) {
-    const [nodeModule, exportName] = executorName.split(':');
+    const [nodeModule, exportName] = (0, executor_utils_1.parseExecutor)(executorName);
     return (0, executor_utils_1.getExecutorInformation)(nodeModule, exportName, workspace_root_1.workspaceRoot, projects);
 }
 async function runTasks(executorName, projectGraph, batchTaskGraph, fullTaskGraph) {

package/src/tasks-runner/create-task-graph.d.ts

@@ -40,4 +40,3 @@ export declare function filterDummyTasks(dependencies: {
 export declare function getNonDummyDeps(currentTask: string, dependencies: {
     [k: string]: string[];
 }, cycles?: Set<string>, seen?: Set<string>): string[];
-export declare function createTaskId(project: string, target: string, configuration: string | undefined): string;

package/src/tasks-runner/create-task-graph.js

@@ -5,7 +5,6 @@ exports.createTaskGraph = createTaskGraph;
 exports.mapTargetDefaultsToDependencies = mapTargetDefaultsToDependencies;
 exports.filterDummyTasks = filterDummyTasks;
 exports.getNonDummyDeps = getNonDummyDeps;
-exports.createTaskId = createTaskId;
 const utils_1 = require("./utils");
 const project_graph_utils_1 = require("../utils/project-graph-utils");
 const output_1 = require("../utils/output");

package/src/tasks-runner/init-tasks-runner.d.ts

@@ -1,8 +1,8 @@
+import type { NxJsonConfiguration } from '../config/nx-json';
 import { NxArgs } from '../utils/command-line-utils';
 import { Task, TaskGraph } from '../config/task-graph';
 import { LifeCycle, TaskResult } from './life-cycle';
 import type { ProjectGraph } from '../config/project-graph';
-import type { NxJsonConfiguration } from '../config/nx-json';
 import { RunningTask } from './running-tasks/running-task';
 /**
  * This function is deprecated. Do not use this

package/src/tasks-runner/init-tasks-runner.js

@@ -99,9 +99,15 @@ async function createOrchestrator(tasks, projectGraph, taskGraphForHashing, nxJs
             return acc;
         }, {}),
     };
-    const orchestrator = new task_orchestrator_1.TaskOrchestrator(hasher, null, [], projectGraph, taskGraph, nxJson, { ...options, parallel: tasks.length, lifeCycle: compositedLifeCycle }, false, client_1.daemonClient, undefined, taskGraphForHashing);
+    const nxArgs = {
+        ...options,
+        parallel: tasks.length,
+        lifeCycle: compositedLifeCycle,
+    };
+    (0, run_command_1.setEnvVarsBasedOnArgs)(nxArgs, true);
+    const orchestrator = new task_orchestrator_1.TaskOrchestrator(hasher, null, [], projectGraph, taskGraph, nxJson, nxArgs, false, client_1.daemonClient, undefined, taskGraphForHashing);
     await orchestrator.init();
-    await Promise.all(tasks.map((task) => orchestrator.processTask(task.id)));
+    orchestrator.processTasks(tasks.map((task) => task.id));
     return orchestrator;
 }
 async function runDiscreteTasks(tasks, projectGraph, taskGraphForHashing, nxJson, lifeCycle) {

package/src/tasks-runner/life-cycles/task-history-life-cycle-old.d.ts

@@ -3,7 +3,9 @@ import { LifeCycle, TaskResult } from '../life-cycle';
 export declare class LegacyTaskHistoryLifeCycle implements LifeCycle {
     private startTimings;
     private taskRuns;
+    private flakyTasks;
     startTasks(tasks: Task[]): void;
     endTasks(taskResults: TaskResult[]): Promise<void>;
     endCommand(): Promise<void>;
+    printFlakyTasksMessage(): void;
 }

package/src/tasks-runner/life-cycles/task-history-life-cycle-old.js

@@ -31,24 +31,27 @@ class LegacyTaskHistoryLifeCycle {
     async endCommand() {
         await (0, legacy_task_history_1.writeTaskRunsToHistory)(this.taskRuns);
         const history = await (0, legacy_task_history_1.getHistoryForHashes)(this.taskRuns.map((t) => t.hash));
-        const flakyTasks = [];
+        this.flakyTasks = [];
         // check if any hash has different exit codes => flaky
         for (let hash in history) {
             if (history[hash].length > 1 &&
                 history[hash].some((run) => run.code !== history[hash][0].code)) {
-                flakyTasks.push((0, serialize_target_1.serializeTarget)(history[hash][0].project, history[hash][0].target, history[hash][0].configuration));
+                this.flakyTasks.push((0, serialize_target_1.serializeTarget)(history[hash][0].project, history[hash][0].target, history[hash][0].configuration));
             }
         }
         // Do not directly print output when using the TUI
         if ((0, is_tui_enabled_1.isTuiEnabled)()) {
             return;
         }
-        if (flakyTasks.length > 0) {
+        this.printFlakyTasksMessage();
+    }
+    printFlakyTasksMessage() {
+        if (this.flakyTasks.length > 0) {
             output_1.output.warn({
-                title: `Nx detected ${flakyTasks.length === 1 ? 'a flaky task' : ' flaky tasks'}`,
+                title: `Nx detected ${this.flakyTasks.length === 1 ? 'a flaky task' : ' flaky tasks'}`,
                 bodyLines: [
                     ,
-                    ...flakyTasks.map((t) => `  ${t}`),
+                    ...this.flakyTasks.map((t) => `  ${t}`),
                     '',
                     `Flaky tasks can disrupt your CI pipeline. Automatically retry them with Nx Cloud. Learn more at https://nx.dev/ci/features/flaky-tasks`,
                 ],

package/src/tasks-runner/life-cycles/task-history-life-cycle.d.ts

@@ -1,10 +1,15 @@
 import { Task } from '../../config/task-graph';
 import { LifeCycle, TaskResult } from '../life-cycle';
+import { LegacyTaskHistoryLifeCycle } from './task-history-life-cycle-old';
+export declare function getTasksHistoryLifeCycle(): TaskHistoryLifeCycle | LegacyTaskHistoryLifeCycle | null;
 export declare class TaskHistoryLifeCycle implements LifeCycle {
     private startTimings;
     private taskRuns;
     private taskHistory;
+    private flakyTasks;
+    constructor();
     startTasks(tasks: Task[]): void;
     endTasks(taskResults: TaskResult[]): Promise<void>;
     endCommand(): Promise<void>;
+    printFlakyTasksMessage(): void;
 }

package/src/tasks-runner/life-cycles/task-history-life-cycle.js

@@ -1,15 +1,37 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.TaskHistoryLifeCycle = void 0;
+exports.getTasksHistoryLifeCycle = getTasksHistoryLifeCycle;
+const native_1 = require("../../native");
 const output_1 = require("../../utils/output");
 const serialize_target_1 = require("../../utils/serialize-target");
 const task_history_1 = require("../../utils/task-history");
 const is_tui_enabled_1 = require("../is-tui-enabled");
+const task_history_life_cycle_old_1 = require("./task-history-life-cycle-old");
+const nx_cloud_utils_1 = require("../../utils/nx-cloud-utils");
+const nx_json_1 = require("../../config/nx-json");
+let tasksHistoryLifeCycle;
+function getTasksHistoryLifeCycle() {
+    if (!(0, nx_cloud_utils_1.isNxCloudUsed)((0, nx_json_1.readNxJson)())) {
+        if (!tasksHistoryLifeCycle) {
+            tasksHistoryLifeCycle =
+                process.env.NX_DISABLE_DB !== 'true' && !native_1.IS_WASM
+                    ? new TaskHistoryLifeCycle()
+                    : new task_history_life_cycle_old_1.LegacyTaskHistoryLifeCycle();
+        }
+        return tasksHistoryLifeCycle;
+    }
+    return null;
+}
 class TaskHistoryLifeCycle {
     constructor() {
         this.startTimings = {};
         this.taskRuns = new Map();
         this.taskHistory = (0, task_history_1.getTaskHistory)();
+        if (tasksHistoryLifeCycle) {
+            throw new Error('TaskHistoryLifeCycle is a singleton and should not be instantiated multiple times');
+        }
+        tasksHistoryLifeCycle = this;
     }
     startTasks(tasks) {
         for (let task of tasks) {
@@ -36,17 +58,20 @@ class TaskHistoryLifeCycle {
             return;
         }
         await this.taskHistory.recordTaskRuns(entries.map(([_, v]) => v));
-        const flakyTasks = await this.taskHistory.getFlakyTasks(entries.map(([hash]) => hash));
+        this.flakyTasks = await this.taskHistory.getFlakyTasks(entries.map(([hash]) => hash));
         // Do not directly print output when using the TUI
         if ((0, is_tui_enabled_1.isTuiEnabled)()) {
             return;
         }
-        if (flakyTasks.length > 0) {
+        this.printFlakyTasksMessage();
+    }
+    printFlakyTasksMessage() {
+        if (this.flakyTasks.length > 0) {
             output_1.output.warn({
-                title: `Nx detected ${flakyTasks.length === 1 ? 'a flaky task' : ' flaky tasks'}`,
+                title: `Nx detected ${this.flakyTasks.length === 1 ? 'a flaky task' : ' flaky tasks'}`,
                 bodyLines: [
                     ,
-                    ...flakyTasks.map((hash) => {
+                    ...this.flakyTasks.map((hash) => {
                         const taskRun = this.taskRuns.get(hash);
                         return `  ${(0, serialize_target_1.serializeTarget)(taskRun.target.project, taskRun.target.target, taskRun.target.configuration)}`;
                     }),

package/src/tasks-runner/life-cycles/tui-summary-life-cycle.js

@@ -7,6 +7,7 @@ const formatting_utils_1 = require("./formatting-utils");
 const pretty_time_1 = require("./pretty-time");
 const view_logs_utils_1 = require("./view-logs-utils");
 const figures = require("figures");
+const task_history_life_cycle_1 = require("./task-history-life-cycle");
 const LEFT_PAD = `   `;
 const SPACER = `  `;
 const EXTENDED_LEFT_PAD = `      `;
@@ -78,6 +79,7 @@ function getTuiTerminalSummaryLifeCycle({ projectNames, tasks, args, overrides,
         else {
             printRunManySummary();
         }
+        (0, task_history_life_cycle_1.getTasksHistoryLifeCycle)()?.printFlakyTasksMessage();
     };
     const printRunOneSummary = () => {
         let lines = [];

package/src/tasks-runner/run-command.d.ts

@@ -17,6 +17,7 @@ export declare function runCommandForTasks(projectsToRun: ProjectGraphProjectNod
     excludeTaskDependencies: boolean;
     loadDotEnvFiles: boolean;
 }): Promise<TaskResults>;
+export declare function setEnvVarsBasedOnArgs(nxArgs: NxArgs, loadDotEnvFiles: boolean): void;
 export declare function invokeTasksRunner({ tasks, projectGraph, taskGraph, lifeCycle, nxJson, nxArgs, loadDotEnvFiles, initiatingProject, initiatingTasks, }: {
     tasks: Task[];
     projectGraph: ProjectGraph;

package/src/tasks-runner/run-command.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.runCommand = runCommand;
 exports.runCommandForTasks = runCommandForTasks;
+exports.setEnvVarsBasedOnArgs = setEnvVarsBasedOnArgs;
 exports.invokeTasksRunner = invokeTasksRunner;
 exports.constructLifeCycles = constructLifeCycles;
 exports.getRunner = getRunner;
@@ -14,7 +15,6 @@ const nx_json_1 = require("../config/nx-json");
 const client_1 = require("../daemon/client/client");
 const create_task_hasher_1 = require("../hasher/create-task-hasher");
 const hash_task_1 = require("../hasher/hash-task");
-const native_1 = require("../native");
 const tasks_execution_hooks_1 = require("../project-graph/plugins/tasks-execution-hooks");
 const project_graph_1 = require("../project-graph/project-graph");
 const fileutils_1 = require("../utils/fileutils");
@@ -34,7 +34,6 @@ const static_run_many_terminal_output_life_cycle_1 = require("./life-cycles/stat
 const static_run_one_terminal_output_life_cycle_1 = require("./life-cycles/static-run-one-terminal-output-life-cycle");
 const store_run_information_life_cycle_1 = require("./life-cycles/store-run-information-life-cycle");
 const task_history_life_cycle_1 = require("./life-cycles/task-history-life-cycle");
-const task_history_life_cycle_old_1 = require("./life-cycles/task-history-life-cycle-old");
 const task_profiling_life_cycle_1 = require("./life-cycles/task-profiling-life-cycle");
 const task_results_life_cycle_1 = require("./life-cycles/task-results-life-cycle");
 const task_timings_life_cycle_1 = require("./life-cycles/task-timings-life-cycle");
@@ -633,10 +632,9 @@ function constructLifeCycles(lifeCycle) {
     if (process.env.NX_PROFILE) {
         lifeCycles.push(new task_profiling_life_cycle_1.TaskProfilingLifeCycle(process.env.NX_PROFILE));
     }
-    if (!(0, nx_cloud_utils_1.isNxCloudUsed)((0, nx_json_1.readNxJson)())) {
-        lifeCycles.push(process.env.NX_DISABLE_DB !== 'true' && !native_1.IS_WASM
-            ? new task_history_life_cycle_1.TaskHistoryLifeCycle()
-            : new task_history_life_cycle_old_1.LegacyTaskHistoryLifeCycle());
+    const historyLifeCycle = (0, task_history_life_cycle_1.getTasksHistoryLifeCycle)();
+    if (historyLifeCycle) {
+        lifeCycles.push(historyLifeCycle);
     }
     return lifeCycles;
 }

package/src/tasks-runner/task-orchestrator.d.ts

@@ -42,7 +42,8 @@ export declare class TaskOrchestrator {
         [id: string]: TaskStatus;
     }>;
     private executeNextBatchOfTasksUsingTaskSchedule;
-    processTask(taskId: string): Promise<NodeJS.ProcessEnv>;
+    processTasks(taskIds: string[]): void;
+    private processTask;
     private processScheduledBatch;
     private processAllScheduledTasks;
     private applyCachedResults;

package/src/tasks-runner/task-orchestrator.js

@@ -124,6 +124,14 @@ class TaskOrchestrator {
         // block until some other task completes, then try again
         return new Promise((res) => this.waitingForTasks.push(res)).then(() => this.executeNextBatchOfTasksUsingTaskSchedule());
     }
+    processTasks(taskIds) {
+        for (const taskId of taskIds) {
+            // Task is already handled or being handled
+            if (!this.processedTasks.has(taskId)) {
+                this.processedTasks.set(taskId, this.processTask(taskId));
+            }
+        }
+    }
     // region Processing Scheduled Tasks
     async processTask(taskId) {
         const task = this.taskGraph.tasks[taskId];
@@ -147,12 +155,7 @@ class TaskOrchestrator {
         for (const batch of scheduledBatches) {
             this.processedBatches.set(batch, this.processScheduledBatch(batch));
         }
-        for (const taskId of scheduledTasks) {
-            // Task is already handled or being handled
-            if (!this.processedTasks.has(taskId)) {
-                this.processedTasks.set(taskId, this.processTask(taskId));
-            }
-        }
+        this.processTasks(scheduledTasks);
     }
     // endregion Processing Scheduled Tasks
     // region Applying Cache
@@ -545,6 +548,9 @@ class TaskOrchestrator {
         for (const { taskId, status } of taskResults) {
             if (this.completedTasks[taskId] === undefined) {
                 this.completedTasks[taskId] = status;
+                if (this.tuiEnabled) {
+                    this.options.lifeCycle.setTaskStatus(taskId, (0, native_1.parseTaskStatus)(status));
+                }
                 if (status === 'failure' || status === 'skipped') {
                     if (this.bail) {
                         // mark the execution as bailed which will stop all further execution

package/src/tasks-runner/utils.js

@@ -294,7 +294,7 @@ function getExecutorNameForTask(task, projectGraph) {
 }
 function getExecutorForTask(task, projectGraph) {
     const executor = getExecutorNameForTask(task, projectGraph);
-    const [nodeModule, executorName] = executor.split(':');
+    const [nodeModule, executorName] = (0, executor_utils_1.parseExecutor)(executor);
     return (0, executor_utils_1.getExecutorInformation)(nodeModule, executorName, workspace_root_1.workspaceRoot, (0, project_graph_1.readProjectsConfigurationFromProjectGraph)(projectGraph).projects);
 }
 function getCustomHasher(task, projectGraph) {

package/src/utils/package-json.d.ts

@@ -74,7 +74,7 @@ export declare function readNxMigrateConfig(json: Partial<PackageJson>): NxMigra
 export declare function buildTargetFromScript(script: string, scripts: Record<string, string>, packageManagerCommand: PackageManagerCommands): TargetConfiguration;
 export declare function getMetadataFromPackageJson(packageJson: PackageJson, isInPackageManagerWorkspaces: boolean): ProjectMetadata;
 export declare function getTagsFromPackageJson(packageJson: PackageJson): string[];
-export declare function readTargetsFromPackageJson(packageJson: PackageJson, nxJson: NxJsonConfiguration): Record<string, TargetConfiguration<any>>;
+export declare function readTargetsFromPackageJson(packageJson: PackageJson, nxJson: NxJsonConfiguration, projectRoot: string, workspaceRoot: string): Record<string, TargetConfiguration<any>>;
 /**
  * Uses `require.resolve` to read the package.json for a module.
  *

package/src/utils/package-json.js

@@ -83,7 +83,7 @@ function getTagsFromPackageJson(packageJson) {
     }
     return tags;
 }
-function readTargetsFromPackageJson(packageJson, nxJson) {
+function readTargetsFromPackageJson(packageJson, nxJson, projectRoot, workspaceRoot) {
     const { scripts, nx, private: isPrivate } = packageJson ?? {};
     const res = {};
     const includedScripts = nx?.includedScripts || Object.keys(scripts ?? {});
@@ -102,7 +102,9 @@ function readTargetsFromPackageJson(packageJson, nxJson) {
      * Any targetDefaults for the nx-release-publish target set by the user should
      * be merged with the implicit target.
      */
-    if (!isPrivate && !res['nx-release-publish']) {
+    if (!isPrivate &&
+        !res['nx-release-publish'] &&
+        hasNxJsPlugin(projectRoot, workspaceRoot)) {
         const nxReleasePublishTargetDefaults = nxJson?.targetDefaults?.['nx-release-publish'] ?? {};
         res['nx-release-publish'] = {
             executor: '@nx/js:release-publish',
@@ -119,6 +121,18 @@ function readTargetsFromPackageJson(packageJson, nxJson) {
     }
     return res;
 }
+function hasNxJsPlugin(projectRoot, workspaceRoot) {
+    try {
+        // nx-ignore-next-line
+        require.resolve('@nx/js', {
+            paths: [projectRoot, ...(0, installation_directory_1.getNxRequirePaths)(workspaceRoot), __dirname],
+        });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
 /**
  * Uses `require.resolve` to read the package.json for a module.
  *

package/src/migrations/update-17-0-0/move-cache-directory.d.ts

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

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

@@ -1,35 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.default = moveCacheDirectory;
-const ignore_1 = require("ignore");
-function moveCacheDirectory(tree) {
-    // If nx.json doesn't exist the repo can't utilize
-    // caching, so .nx/cache is less relevant. Lerna users
-    // that don't want to fully opt in to Nx at this time
-    // may also be caught off guard by the appearance of
-    // a .nx directory, so we are going to special case
-    // this for the time being.
-    if (tree.exists('lerna.json') && !tree.exists('nx.json')) {
-        return;
-    }
-    updateGitIgnore(tree);
-    if (tree.exists('.prettierignore')) {
-        const ignored = tree.read('.prettierignore', 'utf-8');
-        if (!ignored.includes('.nx/cache')) {
-            tree.write('.prettierignore', [ignored, '/.nx/cache'].join('\n'));
-        }
-    }
-}
-function updateGitIgnore(tree) {
-    const gitignore = tree.exists('.gitignore')
-        ? tree.read('.gitignore', 'utf-8')
-        : '';
-    const ig = (0, ignore_1.default)();
-    ig.add(gitignore);
-    if (!ig.ignores('.nx/cache')) {
-        const updatedLines = gitignore.length
-            ? [gitignore, '.nx/cache']
-            : ['.nx/cache'];
-        tree.write('.gitignore', updatedLines.join('\n'));
-    }
-}

package/src/migrations/update-17-0-0/rm-default-collection-npm-scope.js

@@ -1,72 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.default = update;
-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 json_1 = require("../../generators/utils/json");
-const output_1 = require("../../utils/output");
-const path_1 = require("../../utils/path");
-async function update(tree) {
-    if (!tree.exists('nx.json')) {
-        return;
-    }
-    const nxJson = (0, nx_json_1.readNxJson)(tree);
-    delete nxJson.cli?.['defaultCollection'];
-    if (nxJson?.cli && Object.keys(nxJson.cli).length < 1) {
-        delete nxJson.cli;
-    }
-    warnNpmScopeHasChanged(tree, nxJson);
-    delete nxJson['npmScope'];
-    (0, nx_json_1.updateNxJson)(tree, nxJson);
-    await (0, format_changed_files_with_prettier_if_available_1.formatChangedFilesWithPrettierIfAvailable)(tree);
-}
-function warnNpmScopeHasChanged(tree, nxJson) {
-    const originalScope = nxJson['npmScope'];
-    // There was no original scope
-    if (!originalScope) {
-        return false;
-    }
-    // package.json does not exist
-    if (!tree.exists('package.json')) {
-        return false;
-    }
-    const newScope = getNpmScopeFromPackageJson(tree);
-    // New and Original scope are the same.
-    if (originalScope === newScope) {
-        return false;
-    }
-    const packageJsonName = (0, json_1.readJson)(tree, 'package.json').name;
-    if (newScope) {
-        output_1.output.warn({
-            title: 'npmScope has been removed from nx.json',
-            bodyLines: [
-                'This will now be read from package.json',
-                `Old value which was in nx.json: ${originalScope}`,
-                `New value from package.json: ${newScope}`,
-                `Typescript path mappings for new libraries will now be generated as such: @${newScope}/new-lib instead of @${originalScope}/new-lib`,
-                `If you would like to change this back, change the name in package.json to ${packageJsonName.replace(newScope, originalScope)}`,
-            ],
-        });
-    }
-    else {
-        // There is no scope in package.json
-        output_1.output.warn({
-            title: 'npmScope has been removed from nx.json',
-            bodyLines: [
-                'This will now be read from package.json',
-                `Old value which was in nx.json: ${originalScope}`,
-                `New value from package.json: null`,
-                `Typescript path mappings for new libraries will now be generated as such: new-lib instead of @${originalScope}/new-lib`,
-                `If you would like to change this back, change the name in package.json to ${(0, path_1.joinPathFragments)(`@${originalScope}`, packageJsonName)}`,
-            ],
-        });
-    }
-}
-function getNpmScopeFromPackageJson(tree) {
-    const { name } = tree.exists('package.json')
-        ? (0, json_1.readJson)(tree, 'package.json')
-        : { name: null };
-    if (name?.startsWith('@')) {
-        return name.split('/')[0].substring(1);
-    }
-}

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

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