nx 23.3.0-beta.8 → 23.3.0-beta.9

package/dist/src/project-graph/affected/affected-tasks.js

@@ -14,6 +14,7 @@ const file_utils_1 = require("../file-utils");
 const find_matching_projects_1 = require("../../utils/find-matching-projects");
 const logger_1 = require("../../utils/logger");
 const error_types_1 = require("../error-types");
+const affected_reasons_1 = require("./affected-reasons");
 const workspace_root_1 = require("../../utils/workspace-root");
 const task_planning_context_1 = require("../../hasher/task-planning-context");
 const client_1 = require("../../daemon/client/client");
@@ -21,6 +22,7 @@ const is_on_daemon_1 = require("../../daemon/is-on-daemon");
 const affected_projects_1 = require("./affected-projects");
 const lock_file_changes_1 = require("../../plugins/js/project-graph/affected/lock-file-changes");
 const npm_packages_1 = require("../../plugins/js/project-graph/affected/npm-packages");
+const lock_file_1 = require("../../plugins/js/lock-file/lock-file");
 /**
  * Whether `nx affected` selects the individual tasks whose inputs a change
  * reaches, rather than whole projects. Off by default while the task path
@@ -51,6 +53,7 @@ async function computeAffectedTasks(opts) {
         excludeTaskDependencies: opts.excludeTaskDependencies ?? false,
         exclude: opts.exclude ?? [],
         selectivelyHashTsConfig: opts.selectivelyHashTsConfig,
+        explain: opts.explain,
     };
     const ultracacheConfigurations = (0, store_1.configurationsOf)(opts.ultracacheConfigurationOutcome ?? null);
     if (ultracacheConfigurations) {
@@ -65,6 +68,7 @@ async function computeAffectedTasks(opts) {
             return {
                 ...selection,
                 affectedTaskIds: new Set(selection.affectedTaskIds),
+                explanation: selection.explanation && (0, affected_reasons_1.hydrateExplanation)(selection.explanation),
                 taskSelection: {
                     ...selection.taskSelection,
                     ultracacheConfigurationOutcome: opts.ultracacheConfigurationOutcome,
@@ -91,6 +95,7 @@ async function computeAffectedTasks(opts) {
         projectGraph,
         affectedTaskIds: selection.affectedTaskIds,
         taskGraph: selection.taskGraph,
+        explanation: selection.explanation && (0, affected_reasons_1.hydrateExplanation)(selection.explanation),
         taskSelection: {
             ...selection.taskSelection,
             // The planner remembers what selection planned, so the run's hashing reuses it.
@@ -122,6 +127,15 @@ async function selectAffectedTasks(projectGraph, nxJson, planningContext, reques
             affectedTaskIds: new Set(),
             taskGraph: empty,
             taskSelection: { taskGraph: empty, initiatingTaskIds: [], taskIds: [] },
+            explanation: request.explain
+                ? {
+                    inputs: [],
+                    affected: {},
+                    upstream: {},
+                    touched: [],
+                    requested: { targets, total: 0 },
+                }
+                : undefined,
         };
     }
     const { taskGraph, dependencyOverrides } = (0, create_task_graph_1.createTaskGraphWithDependencyOverrides)(projectGraph, request.extraTargetDependencies, candidates, targets, request.configuration, request.overrides, 
@@ -134,11 +148,12 @@ async function selectAffectedTasks(projectGraph, nxJson, planningContext, reques
     const dependencies = dependencyChanges(projectGraph, touchedFiles, nxJson, packageJson);
     const namedProjects = new Set(dependencies.projects);
     const projects = (0, project_graph_1.readProjectsConfigurationFromProjectGraph)(projectGraph).projects;
-    const selection = (0, native_1.affectedTasks)(planningContext.projectGraphRef, plans, taskGraph, request.changedFiles, {
+    const customHashed = new Set(taskIds.filter((id) => hasCustomHasher(taskGraph.tasks[id], projects)));
+    const options = {
         projectGlobPatterns: await (0, affected_projects_1.getProjectGlobPatterns)(nxJson),
         workspaceRoot: workspace_root_1.workspaceRoot,
         alwaysTouchedTaskIds: taskIds.filter((id) => namedProjects.has(taskGraph.tasks[id].target.project) ||
-            hasCustomHasher(taskGraph.tasks[id], projects)),
+            customHashed.has(id)),
         changedExternals: dependencies.externals,
         changedExternalTypes: dependencies.changedExternalTypes,
         excludedProjects: request.exclude.length
@@ -147,7 +162,9 @@ async function selectAffectedTasks(projectGraph, nxJson, planningContext, reques
         targets,
         revisions: fileRevisions(request.fileChangeArgs),
         selectivelyHashTsConfig: request.selectivelyHashTsConfig ?? false,
-    });
+        explain: request.explain ?? false,
+    };
+    const selection = (0, native_1.affectedTasks)(planningContext.projectGraphRef, plans, taskGraph, request.changedFiles, options);
     // The run builds from the owning projects, so only their requested tasks
     // take the CLI overrides there; every other task is a dependency.
     const owning = new Set(selection.affected.map((id) => taskGraph.tasks[id].target.project));
@@ -162,6 +179,10 @@ async function selectAffectedTasks(projectGraph, nxJson, planningContext, reques
     return {
         affectedTaskIds: new Set(selection.affected),
         taskGraph,
+        explanation: selection.explanation && {
+            ...explainTasks(selection.affected, selection.explanation, dependencies, request.changedFiles, taskGraph, customHashed, keep),
+            requested: requestedTasks(taskIds, taskGraph, targets, options),
+        },
         taskSelection: {
             // Edges that disagree on a dependency's overrides leave it to a build
             // from the owning projects, which settles them the way the run always has.
@@ -191,20 +212,175 @@ function hasCustomHasher(task, projects) {
         return false;
     }
 }
-/**
- * A lockfile or package.json change reaches a hash as `External(name)`, a
- * package rather than a path, so it is handed to the plans as package names.
- */
 function dependencyChanges(projectGraph, touchedFiles, nxJson, packageJson = (0, file_utils_1.readPackageJson)()) {
-    const changes = [
-        (0, lock_file_changes_1.lockFileDependencyChanges)(touchedFiles, projectGraph.nodes, nxJson, packageJson, projectGraph),
-        (0, npm_packages_1.packageJsonDependencyChanges)(touchedFiles, nxJson, projectGraph),
-    ];
+    const lockFile = (0, lock_file_changes_1.lockFileDependencyChanges)(touchedFiles, projectGraph.nodes, nxJson, packageJson, projectGraph);
+    const packageJsonChanges = (0, npm_packages_1.packageJsonDependencyChanges)(touchedFiles, nxJson, projectGraph);
+    const changes = [lockFile, packageJsonChanges];
+    const named = new Map();
+    const name = (project, reason) => named.set(project, [...(named.get(project) ?? []), reason]);
+    const changedLockFile = touchedFiles.find((f) => lock_file_1.AUTO_AFFECTED_LOCK_FILES.includes(f.file))?.file;
+    for (const project of lockFile.projects) {
+        name(project, { kind: 'lockfile', file: changedLockFile });
+    }
+    for (const project of packageJsonChanges.projects) {
+        name(project, {
+            kind: 'npm-package',
+            // The name package.json uses, which need not be the project's.
+            package: projectGraph.nodes[project]?.data.metadata?.js?.packageName ?? project,
+            file: 'package.json',
+        });
+    }
+    const movedBy = new Map();
+    for (const external of packageJsonChanges.externals) {
+        movedBy.set(external, 'package.json');
+    }
+    for (const external of lockFile.externals) {
+        movedBy.set(external, changedLockFile);
+    }
+    const ecosystemMovedBy = new Map();
+    for (const [changes, file] of [
+        [packageJsonChanges, 'package.json'],
+        [lockFile, changedLockFile],
+    ]) {
+        for (const ecosystem of changes.changedExternalTypes) {
+            ecosystemMovedBy.set(ecosystem, [
+                ...(ecosystemMovedBy.get(ecosystem) ?? []),
+                file,
+            ]);
+        }
+    }
     return {
         externals: [...new Set(changes.flatMap((c) => c.externals))],
         changedExternalTypes: [
             ...new Set(changes.flatMap((c) => c.changedExternalTypes)),
         ],
         projects: [...new Set(changes.flatMap((c) => c.projects))],
+        named,
+        movedBy,
+        ecosystemMovedBy,
+    };
+}
+/**
+ * Why each selected task is in the answer, and why each task outside it that
+ * a reason names as a producer is too.
+ *
+ * Every reason that applies is listed: a task can match a changed file, hash a package that
+ * moved, and read an affected producer, all at once.
+ */
+function explainTasks(affected, explanation, dependencies, changedPaths, taskGraph, customHashed, 
+/** What the run keeps: a reached task in it is listed even if nothing reads its outputs. */
+keep) {
+    // What a plan hashing every external saw change.
+    const dependencyFiles = changedPaths.filter((file) => file === 'package.json' ||
+        lock_file_1.AUTO_AFFECTED_LOCK_FILES.includes(file));
+    const named = dependencies.named;
+    // Each matching instruction's reasons, built once and shared by every task
+    // whose plan holds it.
+    const inputs = explanation.inputMatches.map((matches) => {
+        const reasons = [];
+        for (const match of matches.files) {
+            reasons.push({
+                kind: 'input-file',
+                file: match.file,
+                pattern: match.pattern,
+            });
+        }
+        for (const pkg of matches.packages) {
+            reasons.push({
+                kind: 'npm-package',
+                package: pkg,
+                file: dependencies.movedBy.get(pkg),
+            });
+        }
+        for (const ecosystem of matches.movedEcosystems) {
+            // Only the files that could not be narrowed: a package.json naming its
+            // packages beside an unreadable lockfile did not move everything.
+            const files = dependencyFiles.filter((file) => dependencies.ecosystemMovedBy.get(ecosystem)?.includes(file));
+            for (const file of files.length ? files : [undefined]) {
+                reasons.push({ kind: 'moved-ecosystem', ecosystem, file });
+            }
+        }
+        if (matches.allExternals) {
+            for (const file of dependencyFiles) {
+                reasons.push({ kind: 'external-dependencies', file });
+            }
+        }
+        for (const file of matches.projectConfigs) {
+            reasons.push({ kind: 'project-configuration', file });
+        }
+        return reasons;
+    });
+    const reasonsFor = (taskId) => {
+        const forTask = [];
+        const matched = (explanation.taskInputMatches[taskId] ?? []).filter((index) => inputs[index].length);
+        if (matched.length) {
+            forTask.push({ kind: 'inputs', inputs: matched });
+        }
+        // Only the reached producers: the walk records the edges it crossed.
+        for (const producer of explanation.producersOf[taskId] ?? []) {
+            forTask.push({ kind: 'dependent-output', producer });
+        }
+        const project = taskGraph.tasks[taskId]?.target.project;
+        for (const reason of (project && named.get(project)) ?? []) {
+            forTask.push(reason);
+        }
+        if (customHashed.has(taskId)) {
+            forTask.push({ kind: 'custom-hasher' });
+        }
+        // A deleted config seeded every task. Only worth saying when nothing
+        // narrower applies, or it would repeat on every line.
+        if (!forTask.length) {
+            for (const file of explanation.deletedProjectConfigs) {
+                forTask.push({ kind: 'deleted-project-configuration', file });
+            }
+        }
+        return forTask;
+    };
+    const result = {
+        inputs,
+        affected: Object.fromEntries(affected.map((id) => [id, reasonsFor(id)])),
+        upstream: {},
+        touched: [],
+    };
+    // Reached: touched, or carried to through outputs, which leaves an edge.
+    const reached = new Set([
+        ...explanation.touched,
+        ...Object.keys(explanation.producersOf),
+    ]);
+    for (const id of keep) {
+        if (reached.has(id) && !(id in result.affected)) {
+            result.upstream[id] = reasonsFor(id);
+        }
+    }
+    const producers = [
+        ...Object.keys(result.affected),
+        ...Object.keys(result.upstream),
+    ].flatMap((id) => explanation.producersOf[id] ?? []);
+    while (producers.length) {
+        const id = producers.pop();
+        if (id in result.affected || id in result.upstream)
+            continue;
+        result.upstream[id] = reasonsFor(id);
+        producers.push(...(explanation.producersOf[id] ?? []));
+    }
+    result.touched = explanation.touched.filter((id) => id in result.affected || id in result.upstream);
+    for (const [pkg, file] of dependencies.movedBy) {
+        result.moved ??= {};
+        (result.moved[file] ??= []).push(pkg);
+    }
+    return result;
+}
+/**
+ * How many tasks of the requested targets selection chose among. Tasks of
+ * excluded projects are left out, since they were never candidates.
+ */
+function requestedTasks(taskIds, taskGraph, targets, options) {
+    const excluded = new Set(options.excludedProjects);
+    return {
+        targets,
+        total: taskIds.filter((id) => {
+            const { project, target } = taskGraph.tasks[id].target;
+            return targets.includes(target) && !excluded.has(project);
+        }).length,
     };
 }

package/dist/src/project-graph/affected/print-explanation.d.ts

@@ -0,0 +1,11 @@
+import { AffectedExplanation } from './affected-reasons';
+/**
+ * Prints `--explain` output.
+ *
+ * `destination` is what the flag was given, following `--graph`: `true` is a
+ * bare `--explain` and prints the human form, `"stdout"` prints JSON, and any
+ * other string is a file to write the JSON to.
+ */
+export declare function printAffectedExplanation(explanation: AffectedExplanation, heading: string, destination: string | boolean | undefined, options?: {
+    verbose?: boolean;
+}): void;

package/dist/src/project-graph/affected/print-explanation.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.printAffectedExplanation = printAffectedExplanation;
+const tslib_1 = require("tslib");
+const fs_1 = require("fs");
+const pc = tslib_1.__importStar(require("picocolors"));
+const output_1 = require("../../utils/output");
+const affected_reasons_1 = require("./affected-reasons");
+/**
+ * Prints `--explain` output.
+ *
+ * `destination` is what the flag was given, following `--graph`: `true` is a
+ * bare `--explain` and prints the human form, `"stdout"` prints JSON, and any
+ * other string is a file to write the JSON to.
+ */
+function printAffectedExplanation(explanation, heading, destination, options = {}) {
+    if (destination === 'stdout') {
+        console.log(JSON.stringify(explanation, null, 2));
+        return;
+    }
+    if (typeof destination === 'string' && destination) {
+        (0, fs_1.writeFileSync)(destination, JSON.stringify(explanation, null, 2));
+        output_1.output.success({ title: `Reasons written to ${destination}` });
+        return;
+    }
+    const rendered = (0, affected_reasons_1.formatAffectedExplanation)(explanation, heading, {
+        ...options,
+        styleTask,
+        dim: pc.dim,
+        bold: pc.bold,
+    });
+    if (!Object.keys(explanation.affected).length) {
+        output_1.output.log({ title: rendered });
+        return;
+    }
+    const [title, , ...bodyLines] = rendered.split('\n');
+    output_1.output.log({ title: title.replace(/:$/, ''), bodyLines });
+}
+// Colored like `nx show target`, with the tasks asked for in bold.
+function styleTask(id, requested) {
+    const split = id.indexOf(':');
+    const colored = `${pc.cyan(id.slice(0, split))}:${pc.green(id.slice(split + 1))}`;
+    return requested ? pc.bold(colored) : colored;
+}

package/dist/src/tasks-runner/default-tasks-runner.js

@@ -68,7 +68,7 @@ const defaultTasksRunner = async (tasks, options, context) => {
 };
 exports.defaultTasksRunner = defaultTasksRunner;
 async function runAllTasks(options, context) {
-    const orchestrator = new task_orchestrator_1.TaskOrchestrator(context.hasher, context.initiatingProject, context.initiatingTasks, context.projectGraph, context.taskGraph, context.nxJson, options, context.nxArgs?.nxBail, context.daemon, context.nxArgs?.specifiedOutputStyle, context.nxArgs?.resolvedOutputStyle ?? 'static-failures-only');
+    const orchestrator = new task_orchestrator_1.TaskOrchestrator(context.hasher, context.initiatingProject, context.initiatingTasks, context.projectGraph, context.taskGraph, context.nxJson, options, context.nxArgs?.nxBail, context.daemon, context.nxArgs?.specifiedOutputStyle, context.nxArgs?.resolvedOutputStyle ?? 'static-failures-only', context.taskGraph, context.deferredTaskIds);
     return orchestrator.run();
 }
 exports.default = exports.defaultTasksRunner;

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

@@ -719,7 +719,7 @@ async function invokeTasksRunner({ tasks, projectGraph, taskGraph, lifeCycle, nx
     // this is used for two reasons: to fetch all remote cache hits AND
     // to submit everything that is known in advance to Nx Cloud to run in
     // a distributed fashion
-    await (0, hash_task_1.hashTasksThatDoNotDependOnOutputsOfOtherTasks)(hasher, projectGraph, taskGraph, nxJson, taskDetails, ultracacheConfigurations);
+    const deferredTaskIds = await (0, hash_task_1.hashTasksThatDoNotDependOnOutputsOfOtherTasks)(hasher, projectGraph, taskGraph, nxJson, taskDetails, ultracacheConfigurations);
     reportUltracacheConfigurations(ultracacheConfigurationOutcome, projectGraph, taskGraph, nxArgs);
     const taskResultsLifecycle = new task_results_life_cycle_1.TaskResultsLifeCycle();
     const compositedLifeCycle = new life_cycle_1.CompositeLifeCycle([
@@ -790,6 +790,7 @@ async function invokeTasksRunner({ tasks, projectGraph, taskGraph, lifeCycle, nx
             },
         },
         daemon: client_1.daemonClient,
+        deferredTaskIds,
     });
     if (promiseOrObservable.subscribe) {
         promiseOrObservable = convertObservableToPromise(promiseOrObservable);

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

@@ -26,6 +26,8 @@ export declare class TaskOrchestrator {
     /** What this run renders with, after defaults. */
     private readonly resolvedOutputStyle;
     private readonly fullTaskGraph;
+    /** Tasks the up-front pass left to hash once the tasks they read from have run. */
+    private readonly deferredTaskIds?;
     private taskDetails;
     private cache;
     private readonly tuiEnabled;
@@ -68,7 +70,9 @@ export declare class TaskOrchestrator {
     /** What the user named; undefined means they named nothing. */
     specifiedOutputStyle: OutputStyle | undefined, 
     /** What this run renders with, after defaults. */
-    resolvedOutputStyle: OutputStyle, fullTaskGraph?: TaskGraph);
+    resolvedOutputStyle: OutputStyle, fullTaskGraph?: TaskGraph, 
+    /** Tasks the up-front pass left to hash once the tasks they read from have run. */
+    deferredTaskIds?: ReadonlySet<string>);
     init(): Promise<void>;
     run(): Promise<{
         [k: string]: TaskStatus;
@@ -128,8 +132,8 @@ export declare class TaskOrchestrator {
      * Hash all batch tasks and resolve cache hits topologically.
      *
      * Walks the task graph level by level. Every task gets a preliminary hash
-     * (so startTasks always has a valid hash for Cloud). Tasks with depsOutputs
-     * whose deps weren't cached are ineligible for cache lookup but still
+     * (so startTasks always has a valid hash for Cloud). Tasks the up-front
+     * pass deferred, whose deps weren't cached, are ineligible for cache lookup but still
      * receive a preliminary hash — they'll be re-hashed after execution.
      */
     private applyBatchCachedResults;

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

@@ -12,7 +12,6 @@ const project_graph_1 = require("../project-graph/project-graph");
 const run_commands_impl_1 = require("../executors/run-commands/run-commands.impl");
 const hash_task_1 = require("../hasher/hash-task");
 const task_graph_utils_1 = require("./task-graph-utils");
-const task_hasher_1 = require("../hasher/task-hasher");
 const native_1 = require("../native");
 const db_connection_1 = require("../utils/db-connection");
 const exit_codes_1 = require("../utils/exit-codes");
@@ -52,7 +51,9 @@ class TaskOrchestrator {
     /** What the user named; undefined means they named nothing. */
     specifiedOutputStyle, 
     /** What this run renders with, after defaults. */
-    resolvedOutputStyle, fullTaskGraph = taskGraph) {
+    resolvedOutputStyle, fullTaskGraph = taskGraph, 
+    /** Tasks the up-front pass left to hash once the tasks they read from have run. */
+    deferredTaskIds) {
         this.hasher = hasher;
         this.initiatingProject = initiatingProject;
         this.initiatingTasks = initiatingTasks;
@@ -65,6 +66,7 @@ class TaskOrchestrator {
         this.specifiedOutputStyle = specifiedOutputStyle;
         this.resolvedOutputStyle = resolvedOutputStyle;
         this.fullTaskGraph = fullTaskGraph;
+        this.deferredTaskIds = deferredTaskIds;
         this.taskDetails = (0, hash_task_1.getTaskDetails)();
         this.cache = (0, cache_1.getCache)(this.options);
         this.tuiEnabled = (0, is_tui_enabled_1.isTuiEnabled)();
@@ -477,8 +479,8 @@ class TaskOrchestrator {
      * Hash all batch tasks and resolve cache hits topologically.
      *
      * Walks the task graph level by level. Every task gets a preliminary hash
-     * (so startTasks always has a valid hash for Cloud). Tasks with depsOutputs
-     * whose deps weren't cached are ineligible for cache lookup but still
+     * (so startTasks always has a valid hash for Cloud). Tasks the up-front
+     * pass deferred, whose deps weren't cached, are ineligible for cache lookup but still
      * receive a preliminary hash — they'll be re-hashed after execution.
      */
     async applyBatchCachedResults(batch, doNotSkipCache, groupId) {
@@ -498,8 +500,7 @@ class TaskOrchestrator {
             for (const task of rootTasks) {
                 const depIds = batch.taskGraph.dependencies[task.id];
                 const hasNonCachedDep = depIds.some((id) => nonCachedTaskIds.has(id));
-                if (hasNonCachedDep &&
-                    (0, task_hasher_1.getInputs)(task, this.projectGraph, this.nxJson).depsOutputs.length > 0) {
+                if (hasNonCachedDep && this.deferredTaskIds?.has(task.id)) {
                     nonCachedTaskIds.add(task.id);
                     needsRehashAfterExecution.add(task.id);
                 }
@@ -555,7 +556,7 @@ class TaskOrchestrator {
             await Promise.all(nonCachedTasks.map((task) => this.options.lifeCycle.scheduleTask(task)));
             await this.preRunSteps(nonCachedTasks, { groupId });
         }
-        // Phase 2: Run non-cached tasks, then re-hash depsOutputs tasks
+        // Phase 2: Run non-cached tasks, then re-hash tasks that read their outputs
         const taskIdsToSkip = cachedResults.map((r) => r.task.id);
         let batchResults = [];
         if (taskIdsToSkip.length < tasks.length) {
@@ -568,7 +569,7 @@ class TaskOrchestrator {
                 executorName: batch.executorName,
                 taskGraph: runGraph,
             }, this.batchEnv, groupId);
-            // Re-hash depsOutputs tasks — their dep outputs are now on disk
+            // Re-hash tasks that read dep outputs — those outputs are now on disk
             const tasksToRehash = batchResults
                 .filter((r) => needsRehashAfterExecution.has(r.task.id) &&
                 (r.status === 'success' || r.status === 'failure'))

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

@@ -19,6 +19,8 @@ export type TasksRunner<T = unknown> = (tasks: Task[], options: T, context?: {
     taskGraph?: TaskGraph;
     hasher?: TaskHasher;
     daemon?: DaemonClient;
+    /** Tasks hashed only once the tasks they read outputs from have run. */
+    deferredTaskIds?: ReadonlySet<string>;
 }) => any | Promise<{
     [id: string]: TaskStatus;
 }>;

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

@@ -28,6 +28,7 @@ export interface NxArgs {
     select?: string;
     graph?: string | boolean;
     skipNxCache?: boolean;
+    explain?: string | boolean;
     skipRemoteCache?: boolean;
     /**
      * The style the user named - CLI flag or `NX_DEFAULT_OUTPUT_STYLE`. Left

package/dist/src/utils/create-cli-options.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Turns options into CLI flags: `{ maxWarnings: 0, fix: true }` gives
+ * `--max-warnings=0 --fix`. Arrays repeat the flag; `false`, `null` and
+ * `undefined` give none.
+ */
+export declare function createCliOptions(obj: Record<string, string | number | boolean | string[] | undefined | null>): string[];

package/dist/src/utils/create-cli-options.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createCliOptions = createCliOptions;
+/**
+ * Turns options into CLI flags: `{ maxWarnings: 0, fix: true }` gives
+ * `--max-warnings=0 --fix`. Arrays repeat the flag; `false`, `null` and
+ * `undefined` give none.
+ */
+function createCliOptions(obj) {
+    const args = [];
+    for (const [key, value] of Object.entries(obj)) {
+        if (value === undefined || value === null || value === false) {
+            continue;
+        }
+        const flag = `--${key.replace(/[A-Z]/g, (m) => '-' + m.toLowerCase())}`;
+        if (value === true) {
+            args.push(flag);
+        }
+        else if (Array.isArray(value)) {
+            for (const item of value) {
+                args.push(`${flag}=${item}`);
+            }
+        }
+        else {
+            args.push(`${flag}=${value}`);
+        }
+    }
+    return args;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nx",
-  "version": "23.3.0-beta.8",
+  "version": "23.3.0-beta.9",
   "private": false,
   "type": "commonjs",
   "description": "The core Nx plugin contains the core functionality of Nx like the project graph, nx commands and task orchestration.",
@@ -159,16 +159,16 @@
     }
   },
   "optionalDependencies": {
-    "@nx/nx-darwin-arm64": "23.3.0-beta.8",
-    "@nx/nx-darwin-x64": "23.3.0-beta.8",
-    "@nx/nx-freebsd-x64": "23.3.0-beta.8",
-    "@nx/nx-linux-arm-gnueabihf": "23.3.0-beta.8",
-    "@nx/nx-linux-arm64-gnu": "23.3.0-beta.8",
-    "@nx/nx-linux-arm64-musl": "23.3.0-beta.8",
-    "@nx/nx-linux-x64-gnu": "23.3.0-beta.8",
-    "@nx/nx-linux-x64-musl": "23.3.0-beta.8",
-    "@nx/nx-win32-arm64-msvc": "23.3.0-beta.8",
-    "@nx/nx-win32-x64-msvc": "23.3.0-beta.8"
+    "@nx/nx-darwin-arm64": "23.3.0-beta.9",
+    "@nx/nx-darwin-x64": "23.3.0-beta.9",
+    "@nx/nx-freebsd-x64": "23.3.0-beta.9",
+    "@nx/nx-linux-arm-gnueabihf": "23.3.0-beta.9",
+    "@nx/nx-linux-arm64-gnu": "23.3.0-beta.9",
+    "@nx/nx-linux-arm64-musl": "23.3.0-beta.9",
+    "@nx/nx-linux-x64-gnu": "23.3.0-beta.9",
+    "@nx/nx-linux-x64-musl": "23.3.0-beta.9",
+    "@nx/nx-win32-arm64-msvc": "23.3.0-beta.9",
+    "@nx/nx-win32-x64-msvc": "23.3.0-beta.9"
   },
   "nx-migrations": {
     "migrations": "./migrations.json",