@depup/nx 23.2.1-depup.7 → 23.3.0-depup.0

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

@@ -0,0 +1,386 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.selectsAffectedTasks = selectsAffectedTasks;
+exports.computeAffectedTasks = computeAffectedTasks;
+exports.selectAffectedTasks = selectAffectedTasks;
+const native_1 = require("../../native");
+const overrides_1 = require("../../ultracache/overrides");
+const store_1 = require("../../ultracache/store");
+const create_task_graph_1 = require("../../tasks-runner/create-task-graph");
+const project_graph_utils_1 = require("../../utils/project-graph-utils");
+const utils_1 = require("../../tasks-runner/utils");
+const project_graph_1 = require("../project-graph");
+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");
+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
+ * settles.
+ *
+ * Env-var only, so `nx show projects --affected` and `nx affected` in one CI
+ * script agree. The run also executes the selected tasks' dependencies.
+ */
+function selectsAffectedTasks() {
+    return process.env.NX_LEGACY_AFFECTED === 'false';
+}
+/**
+ * Selects the tasks a change reaches, rather than the projects that own a
+ * changed file.
+ *
+ * With the daemon on, the daemon selects: it hashes the run's tasks, so its
+ * planner is the one that remembers the plans. It returns the graph it selected
+ * against, which the command must run with.
+ */
+async function computeAffectedTasks(opts) {
+    const request = {
+        targets: opts.targets,
+        changedFiles: opts.touchedFiles.map((f) => f.file),
+        fileChangeArgs: opts.fileChangeArgs,
+        configuration: opts.configuration,
+        overrides: opts.overrides ?? {},
+        extraTargetDependencies: opts.extraTargetDependencies ?? {},
+        excludeTaskDependencies: opts.excludeTaskDependencies ?? false,
+        exclude: opts.exclude ?? [],
+        selectivelyHashTsConfig: opts.selectivelyHashTsConfig,
+        explain: opts.explain,
+    };
+    const ultracacheConfigurations = (0, store_1.configurationsOf)(opts.ultracacheConfigurationOutcome ?? null);
+    if (ultracacheConfigurations) {
+        request.ultracacheConfigurationsVersion = {
+            commit: ultracacheConfigurations.commit,
+            fetchedAt: ultracacheConfigurations.resolution.fetchedAt,
+        };
+    }
+    if (!(0, is_on_daemon_1.isOnDaemon)() && client_1.daemonClient.enabled()) {
+        try {
+            const selection = await client_1.daemonClient.selectAffectedTasks(request);
+            return {
+                ...selection,
+                affectedTaskIds: new Set(selection.affectedTaskIds),
+                explanation: selection.explanation && (0, affected_reasons_1.hydrateExplanation)(selection.explanation),
+                taskSelection: {
+                    ...selection.taskSelection,
+                    ultracacheConfigurationOutcome: opts.ultracacheConfigurationOutcome,
+                },
+            };
+        }
+        catch (e) {
+            if (e?.name === error_types_1.DaemonProjectGraphError.name) {
+                throw error_types_1.ProjectGraphError.fromDaemonProjectGraphError(e);
+            }
+            // Not rethrown: the graph fetch handles an unreachable daemon, and a
+            // selection error recurs in-process below.
+            logger_1.logger.verbose(`Selecting affected tasks in the daemon failed: ${e}`);
+        }
+    }
+    const projectGraph = opts.projectGraph ?? (await (0, project_graph_1.createProjectGraphAsync)({ exitOnError: true }));
+    const planningContext = (0, task_planning_context_1.createTaskPlanningContext)(projectGraph, opts.nxJson);
+    const selection = await selectAffectedTasks(projectGraph, opts.nxJson, planningContext, request, {
+        touchedFiles: opts.touchedFiles,
+        packageJson: opts.packageJson,
+        ultracacheConfigurations,
+    });
+    return {
+        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.
+            planningContext,
+            ultracacheConfigurationOutcome: opts.ultracacheConfigurationOutcome,
+        },
+    };
+}
+/**
+ * Plans the targets' full task graph and matches the changed paths against
+ * every plan. No project-level prefilter: under Ultracache configurations a
+ * task can read files no affected project owns. Shared by the client and the
+ * daemon.
+ */
+async function selectAffectedTasks(projectGraph, nxJson, planningContext, request, { touchedFiles = (0, file_utils_1.calculateFileChanges)(request.changedFiles, request.fileChangeArgs), packageJson, ultracacheConfigurations, } = {}) {
+    const { targets } = request;
+    // Only projects that have one of the targets: with a single target,
+    // createTaskGraph tries to create a task for projects that lack it and
+    // createTask throws.
+    const candidates = [...(0, project_graph_utils_1.runnableForTarget)(projectGraph.nodes, targets)];
+    if (!candidates.length) {
+        const empty = {
+            roots: [],
+            tasks: {},
+            dependencies: {},
+            continuousDependencies: {},
+        };
+        return {
+            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, 
+    // Dependencies carry a change even when they won't run; `keep` drops them.
+    false);
+    const taskIds = Object.keys(taskGraph.tasks);
+    const plans = ultracacheConfigurations
+        ? planningContext.planner.getPlansReference(taskIds, taskGraph, ultracacheConfigurations, (0, overrides_1.ultracacheEligibilityOptions)(projectGraph, taskGraph))
+        : planningContext.planner.getPlansReference(taskIds, taskGraph);
+    const dependencies = dependencyChanges(projectGraph, touchedFiles, nxJson, packageJson);
+    const namedProjects = new Set(dependencies.projects);
+    const projects = (0, project_graph_1.readProjectsConfigurationFromProjectGraph)(projectGraph).projects;
+    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) ||
+            customHashed.has(id)),
+        changedExternals: dependencies.externals,
+        changedExternalTypes: dependencies.changedExternalTypes,
+        excludedProjects: request.exclude.length
+            ? (0, find_matching_projects_1.findMatchingProjects)(request.exclude, projectGraph.nodes)
+            : [],
+        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));
+    const initial = new Set(taskIds.filter((id) => {
+        const { project, target } = taskGraph.tasks[id].target;
+        return owning.has(project) && targets.includes(target);
+    }));
+    // Without dependencies the run builds its initial tasks and nothing else.
+    const keep = request.excludeTaskDependencies
+        ? selection.required.filter((id) => initial.has(id))
+        : selection.required;
+    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.
+            taskGraph: (0, create_task_graph_1.filterTaskGraphToSelection)(projectGraph, taskGraph, dependencyOverrides, initial, new Set(keep)) ??
+                (0, utils_1.pruneToSelectedTasks)((0, create_task_graph_1.createTaskGraph)(projectGraph, request.extraTargetDependencies, [...owning], targets, request.configuration, request.overrides, request.excludeTaskDependencies), keep),
+            initiatingTaskIds: keep.filter((id) => initial.has(id)),
+            taskIds: keep,
+        },
+    };
+}
+/** Unset for `--files`, which names files without a diff to compare. */
+function fileRevisions(args) {
+    return args?.base && !args.files?.length
+        ? { base: args.base, head: args.head }
+        : undefined;
+}
+/**
+ * A custom hasher hashes outside the task's plan, so no instruction says what
+ * reaches it and the task is always selected. An executor that cannot be
+ * resolved cannot run either, so it is left to the plan.
+ */
+function hasCustomHasher(task, projects) {
+    try {
+        return !!(0, utils_1.getExecutorForTask)(task, projects).hasherFactory;
+    }
+    catch {
+        return false;
+    }
+}
+function dependencyChanges(projectGraph, touchedFiles, nxJson, packageJson = (0, file_utils_1.readPackageJson)()) {
+    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/project-graph/error-types.d.ts

@@ -66,6 +66,10 @@ export declare class ProjectConfigurationsError extends Error {
     constructor(errors: Array<MergeNodesError | AggregateCreateNodesError | ProjectsWithNoNameError | MultipleProjectsWithSameNameError | WorkspaceValidityError>, partialProjectConfigurationsResult: ConfigurationResult);
 }
 export declare function isProjectConfigurationsError(e: unknown): e is ProjectConfigurationsError;
+export declare function formatProjectGraphError(error: ProjectGraphError | ProjectConfigurationsError, isVerbose: boolean): {
+    title: string;
+    bodyLines: string[];
+};
 /**
  * This error should be thrown when a `createNodesV2` function hits a recoverable error.
  * It allows Nx to recieve partial results and continue processing for better UX.
@@ -149,3 +153,4 @@ export declare class LoadPluginError extends Error {
     plugin: string;
     constructor(plugin: string, cause: Error);
 }
+export declare function formatErrorStackAndCause(error: Error): string;

package/dist/src/project-graph/error-types.js

@@ -7,12 +7,14 @@ exports.isMultipleProjectsWithSameNameError = isMultipleProjectsWithSameNameErro
 exports.isProjectsWithNoNameError = isProjectsWithNoNameError;
 exports.isProjectWithNoNameError = isProjectWithNoNameError;
 exports.isProjectConfigurationsError = isProjectConfigurationsError;
+exports.formatProjectGraphError = formatProjectGraphError;
 exports.formatAggregateCreateNodesError = formatAggregateCreateNodesError;
 exports.isWorkspaceValidityError = isWorkspaceValidityError;
 exports.isAggregateProjectGraphError = isAggregateProjectGraphError;
 exports.isCreateMetadataError = isCreateMetadataError;
 exports.isAggregateCreateNodesError = isAggregateCreateNodesError;
 exports.isMergeNodesError = isMergeNodesError;
+exports.formatErrorStackAndCause = formatErrorStackAndCause;
 const tslib_1 = require("tslib");
 class StaleProjectGraphCacheError extends Error {
     constructor() {
@@ -222,6 +224,27 @@ function isProjectConfigurationsError(e) {
             'name' in e &&
             e?.name === ProjectConfigurationsError.name));
 }
+function formatProjectGraphError(error, isVerbose) {
+    const errors = isProjectConfigurationsError(error)
+        ? error.errors
+        : error.getErrors();
+    let title = error.message;
+    if (error.cause &&
+        typeof error.cause === 'object' &&
+        'message' in error.cause) {
+        title += ' ' + error.cause.message + '.';
+    }
+    return {
+        title,
+        bodyLines: isVerbose
+            ? [formatErrorStackAndCause(error)]
+            : [
+                ...errors.map((e) => e.message),
+                '',
+                'Pass --verbose to see the stacktraces.',
+            ],
+    };
+}
 /**
  * This error should be thrown when a `createNodesV2` function hits a recoverable error.
  * It allows Nx to recieve partial results and continue processing for better UX.
@@ -476,9 +499,25 @@ function indentString(str, indent) {
             .join('\n'));
 }
 function formatErrorStackAndCause(error) {
-    const cause = error.cause && error.cause instanceof Error ? error.cause : null;
-    return (error.stack +
-        (cause
-            ? `\nCaused by: \n${indentString(cause.stack ?? cause.message, 2)}`
-            : ''));
+    const cause = describeCause(error.cause);
+    return ((error.stack ?? error.message) +
+        (cause ? `\nCaused by: \n${indentString(cause, 2)}` : ''));
+}
+function describeCause(cause) {
+    if (!cause) {
+        return null;
+    }
+    if (cause instanceof Error) {
+        return cause.stack ?? cause.message;
+    }
+    if (typeof cause === 'object') {
+        const { stack, message } = cause;
+        if (typeof stack === 'string') {
+            return stack;
+        }
+        if (typeof message === 'string') {
+            return message;
+        }
+    }
+    return String(cause);
 }

package/dist/src/project-graph/file-utils.d.ts

@@ -22,6 +22,8 @@ export declare class LockFileChange implements Change {
 export declare function isWholeFileChange(change: Change): change is WholeFileChange;
 export declare function isDeletedFileChange(change: Change): change is DeletedFileChange;
 export declare function isLockFileChange(change: Change): change is LockFileChange;
+/** Whether a touched file was deleted. Much cheaper than `getChanges()`. */
+export declare function isDeletedFile(file: string): boolean;
 export declare function calculateFileChanges(files: string[], nxArgs?: NxArgs, readFileAtRevision?: {
     (f: string, r: string | void): string;
 }, ignore?: ReturnType<typeof ignore>): FileChange[];

package/dist/src/project-graph/file-utils.js

@@ -4,6 +4,7 @@ exports.TEN_MEGABYTES = exports.LockFileChange = exports.DeletedFileChange = exp
 exports.isWholeFileChange = isWholeFileChange;
 exports.isDeletedFileChange = isDeletedFileChange;
 exports.isLockFileChange = isLockFileChange;
+exports.isDeletedFile = isDeletedFile;
 exports.calculateFileChanges = calculateFileChanges;
 exports.defaultFileRead = defaultFileRead;
 exports.readPackageJson = readPackageJson;
@@ -14,6 +15,7 @@ const path_1 = require("path");
 const fileutils_1 = require("../utils/fileutils");
 const git_revision_1 = require("../utils/git-revision");
 const ignore_1 = require("../utils/ignore");
+const native_1 = require("../native");
 const json_diff_1 = require("../utils/json-diff");
 const workspace_root_1 = require("../utils/workspace-root");
 class WholeFileChange {
@@ -53,6 +55,10 @@ const TEXT_LOCK_FILES = new Set([
     'bun.lock',
 ]);
 const BINARY_LOCK_FILES = new Set(['bun.lockb']);
+/** Whether a touched file was deleted. Much cheaper than `getChanges()`. */
+function isDeletedFile(file) {
+    return !(0, fs_1.existsSync)((0, path_1.join)(workspace_root_1.workspaceRoot, file));
+}
 function calculateFileChanges(files, nxArgs, readFileAtRevision = defaultReadFileAtRevision, ignore = (0, ignore_1.getIgnoreObject)()) {
     files = files.filter((f) => !ignore.ignores(f));
     return files.map((f) => {
@@ -61,7 +67,7 @@ function calculateFileChanges(files, nxArgs, readFileAtRevision = defaultReadFil
         return {
             file: f,
             getChanges: () => {
-                if (!(0, fs_1.existsSync)((0, path_1.join)(workspace_root_1.workspaceRoot, f))) {
+                if (isDeletedFile(f)) {
                     return [new DeletedFileChange()];
                 }
                 if (!nxArgs) {
@@ -85,7 +91,10 @@ function calculateFileChanges(files, nxArgs, readFileAtRevision = defaultReadFil
                         try {
                             const atBase = readFileAtRevision(f, nxArgs.base);
                             const atHead = readFileAtRevision(f, nxArgs.head);
-                            return (0, json_diff_1.jsonDiff)(JSON.parse(atBase), JSON.parse(atHead));
+                            // Unset when either side is not strict JSON.
+                            return ((0, native_1.diffJson)(atBase, atHead) ?? [
+                                new WholeFileChange(),
+                            ]);
                         }
                         catch (e) {
                             return [new WholeFileChange()];
@@ -123,7 +132,7 @@ function defaultReadFileAtRevision(file, revision) {
     try {
         const filePathInGitRepository = getFilePathInGitRepository(file);
         return !revision
-            ? (0, fs_1.readFileSync)(file, 'utf-8')
+            ? (0, fs_1.readFileSync)((0, path_1.join)(workspace_root_1.workspaceRoot, file), 'utf-8')
             : (0, child_process_1.execFileSync)('git', ['show', `${revision}:${filePathInGitRepository}`], {
                 maxBuffer: exports.TEN_MEGABYTES,
                 stdio: ['pipe', 'pipe', 'ignore'],

package/dist/src/project-graph/nx-deps-cache.d.ts

@@ -17,7 +17,10 @@ export declare const nxFileMap: string;
 export declare const nxSourceMaps: string;
 export declare function ensureCacheDirectory(): void;
 export declare function readFileMapCache(): null | FileMapCache;
-export declare function readProjectGraphCache(minimumComputedAt?: number): null | ProjectGraph;
+export declare function readProjectGraphCache(minimumComputedAt?: number): null | {
+    projectGraph: ProjectGraph;
+    computedAt: number | undefined;
+};
 export declare function readSourceMapsCache(): null | ConfigurationSourceMaps;
 export declare function createProjectFileMapCache(nxJson: NxJsonConfiguration<'*' | string[]>, packageJsonDeps: Record<string, string>, fileMap: FileMap, tsConfig: {
     compilerOptions?: {
@@ -26,7 +29,7 @@ export declare function createProjectFileMapCache(nxJson: NxJsonConfiguration<'*
         };
     };
 }, externalNodesHash: string): FileMapCache;
-export declare function writeCache(cache: FileMapCache, projectGraph: ProjectGraph, sourceMaps: ConfigurationSourceMaps, errors: ProjectGraphErrorTypes[]): void;
+export declare function writeCache(cache: FileMapCache, projectGraph: ProjectGraph, sourceMaps: ConfigurationSourceMaps, errors: ProjectGraphErrorTypes[], computedAt: number): void;
 /**
  * Writes the cache only if the on-disk cache file has been modified since
  * this process last wrote it (i.e. an external process overwrote it), or

package/dist/src/project-graph/nx-deps-cache.js

@@ -83,7 +83,7 @@ function readProjectGraphCache(minimumComputedAt) {
                 }
                 throw new error_types_1.ProjectGraphError(errors, projectGraphCache, readSourceMapsCache());
             }
-            return projectGraphCache;
+            return { projectGraph: projectGraphCache, computedAt };
         }
         else {
             return null;
@@ -140,7 +140,7 @@ function createProjectFileMapCache(nxJson, packageJsonDeps, fileMap, tsConfig, e
  * when no external process has modified the cache file since the last write.
  */
 let lastWrittenCacheMtimeMs;
-function writeCache(cache, projectGraph, sourceMaps, errors) {
+function writeCache(cache, projectGraph, sourceMaps, errors, computedAt) {
     perf_hooks_1.performance.mark('write cache:start');
     let retry = 1;
     let done = false;
@@ -158,7 +158,7 @@ function writeCache(cache, projectGraph, sourceMaps, errors) {
             (0, fileutils_1.writeJsonFile)(tmpProjectGraphPath, {
                 ...projectGraph,
                 errors,
-                computedAt: Date.now(),
+                computedAt,
             });
             (0, node_fs_1.renameSync)(tmpProjectGraphPath, exports.nxProjectGraph);
             (0, fileutils_1.writeJsonFile)(tmpSourceMapPath, sourceMaps);
@@ -221,7 +221,7 @@ function writeCacheIfStale(cache, projectGraph, sourceMaps, errors) {
             // File doesn't exist or can't be stat'd — proceed with write
         }
     }
-    writeCache(cache, projectGraph, sourceMaps, errors);
+    writeCache(cache, projectGraph, sourceMaps, errors, Date.now());
 }
 function shouldRecomputeWholeGraph(cache, packageJsonDeps, projects, nxJson, tsConfig, externalNodesHash) {
     if (cache.version !== '6.0') {