nx 20.8.4 → 22.7.7

package/dist/src/hasher/native-task-hasher-impl.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NativeTaskHasherImpl = void 0;
+const native_1 = require("../native");
+const transform_objects_1 = require("../native/transform-objects");
+const typescript_1 = require("../plugins/js/utils/typescript");
+const task_io_service_1 = require("../tasks-runner/task-io-service");
+const fileutils_1 = require("../utils/fileutils");
+class NativeTaskHasherImpl {
+    constructor(workspaceRoot, nxJson, projectGraph, externals, options) {
+        this.projectGraphRef = (0, native_1.transferProjectGraph)((0, transform_objects_1.transformProjectGraphForRust)(projectGraph));
+        this.allWorkspaceFilesRef = externals.allWorkspaceFiles;
+        this.projectFileMapRef = externals.projectFiles;
+        let tsconfig = {};
+        let paths = {};
+        let rootTsConfigPath = (0, typescript_1.getRootTsConfigPath)();
+        if (rootTsConfigPath) {
+            tsconfig = (0, fileutils_1.readJsonFile)((0, typescript_1.getRootTsConfigPath)());
+            paths = tsconfig.compilerOptions?.paths ?? {};
+            if (tsconfig.compilerOptions?.paths) {
+                delete tsconfig.compilerOptions.paths;
+            }
+        }
+        this.planner = new native_1.HashPlanner(nxJson, this.projectGraphRef);
+        this.hasher = new native_1.TaskHasher(workspaceRoot, this.projectGraphRef, this.projectFileMapRef, this.allWorkspaceFilesRef, Buffer.from(JSON.stringify(tsconfig)), paths, rootTsConfigPath, options);
+    }
+    async hashTask(task, taskGraph, env, cwd, collectInputs) {
+        const hashes = await this.hashTasks([task], taskGraph, { [task.id]: env }, cwd, collectInputs);
+        return hashes[0];
+    }
+    async hashTasks(tasks, taskGraph, perTaskEnvs, cwd, collectInputs) {
+        const plans = this.planner.getPlansReference(tasks.map((t) => t.id), taskGraph);
+        const shouldCollectInputs = collectInputs ?? (0, task_io_service_1.getTaskIOService)().hasTaskInputSubscribers();
+        const hashes = this.hasher.hashPlans(plans, perTaskEnvs, cwd ?? process.cwd(), shouldCollectInputs);
+        return tasks.map((t) => hashes[t.id]);
+    }
+}
+exports.NativeTaskHasherImpl = NativeTaskHasherImpl;

package/dist/src/hasher/task-hasher.d.ts

@@ -0,0 +1,160 @@
+import { FileData, ProjectGraph, ProjectGraphProjectNode } from '../config/project-graph';
+import { NxJsonConfiguration } from '../config/nx-json';
+import { Task, TaskGraph } from '../config/task-graph';
+import { DaemonClient } from '../daemon/client/client';
+import { InputDefinition } from '../config/workspace-json-project-json';
+import { HashInputs, NxWorkspaceFilesExternals } from '../native';
+export { HashInputs };
+/**
+ * A data structure returned by the default hasher.
+ */
+export interface PartialHash {
+    value: string;
+    details: {
+        [name: string]: string;
+    };
+    inputs: HashInputs;
+}
+/**
+ * A data structure returned by the default hasher.
+ */
+export interface Hash {
+    value: string;
+    details: {
+        command: string;
+        nodes: {
+            [name: string]: string;
+        };
+        implicitDeps?: {
+            [fileName: string]: string;
+        };
+        runtime?: {
+            [input: string]: string;
+        };
+    };
+    inputs?: HashInputs;
+}
+export interface TaskHasher {
+    /**
+     * @deprecated use hashTask(task:Task, taskGraph: TaskGraph, env: NodeJS.ProcessEnv) instead. This will be removed in v20
+     * @param task
+     */
+    hashTask(task: Task): Promise<Hash>;
+    /**
+     * @deprecated use hashTask(task:Task, taskGraph: TaskGraph, env: NodeJS.ProcessEnv) instead. This will be removed in v20
+     */
+    hashTask(task: Task, taskGraph: TaskGraph): Promise<Hash>;
+    hashTask(task: Task, taskGraph: TaskGraph, env: NodeJS.ProcessEnv, cwd?: string): Promise<Hash>;
+    /**
+     * @deprecated pass `perTaskEnvs` keyed by `task.id` instead — hashing
+     * every task against one shared env produces the wrong cache key when
+     * tasks have per-project/target `.env` files or custom hashers that
+     * read env. Will be removed in v22.
+     */
+    hashTasks(tasks: Task[], taskGraph: TaskGraph, env: NodeJS.ProcessEnv, cwd?: string): Promise<Hash[]>;
+    /**
+     * Hash `tasks`. `perTaskEnvs` must contain an entry keyed by `task.id`
+     * for every task in `tasks` — task-specific env (per-project/target
+     * `.env` files, custom-hasher env reads) participates in the hash, so
+     * a shared env across tasks would compute the wrong cache key when
+     * tasks actually differ.
+     */
+    hashTasks(tasks: Task[], taskGraph: TaskGraph, perTaskEnvs: Record<string, NodeJS.ProcessEnv>, cwd?: string): Promise<Hash[]>;
+}
+export interface TaskHasherImpl {
+    /**
+     * Hash `tasks` where each task is keyed in `perTaskEnvs` by `task.id`.
+     * Every task must have an entry — callers who want to hash against a
+     * single shared env should construct `{ [task.id]: env }` for every
+     * task.
+     */
+    hashTasks(tasks: Task[], taskGraph: TaskGraph, perTaskEnvs: Record<string, NodeJS.ProcessEnv>, cwd?: string, collectInputs?: boolean): Promise<PartialHash[]>;
+    hashTask(task: Task, taskGraph: TaskGraph, env: NodeJS.ProcessEnv, cwd?: string, collectInputs?: boolean): Promise<PartialHash>;
+}
+export type Hasher = TaskHasher;
+export declare class DaemonBasedTaskHasher implements TaskHasher {
+    private readonly daemonClient;
+    private readonly runnerOptions;
+    constructor(daemonClient: DaemonClient, runnerOptions: any);
+    hashTasks(tasks: Task[], taskGraph: TaskGraph, envOrPerTaskEnvs: NodeJS.ProcessEnv | Record<string, NodeJS.ProcessEnv>): Promise<Hash[]>;
+    hashTask(task: Task, taskGraph?: TaskGraph, env?: NodeJS.ProcessEnv): Promise<Hash>;
+}
+export declare class InProcessTaskHasher implements TaskHasher {
+    private readonly projectGraph;
+    private readonly nxJson;
+    private readonly externalRustReferences;
+    private readonly options;
+    private taskHasher;
+    constructor(projectGraph: ProjectGraph, nxJson: NxJsonConfiguration, externalRustReferences: NxWorkspaceFilesExternals | null, options: any);
+    hashTasks(tasks: Task[], taskGraph: TaskGraph, envOrPerTaskEnvs: NodeJS.ProcessEnv | Record<string, NodeJS.ProcessEnv>, cwd?: string, collectInputs?: boolean): Promise<Hash[]>;
+    hashTask(task: Task, taskGraph?: TaskGraph, env?: NodeJS.ProcessEnv, cwd?: string, collectInputs?: boolean): Promise<Hash>;
+    private createHashDetails;
+    private hashCommand;
+}
+export type ExpandedSelfInput = {
+    fileset: string;
+} | {
+    runtime: string;
+} | {
+    env: string;
+} | {
+    externalDependencies: string[];
+};
+export type ExpandedDepsOutput = {
+    dependentTasksOutputFiles: string;
+    transitive?: boolean;
+};
+export type ExpandedInput = ExpandedSelfInput | ExpandedDepsOutput;
+export declare function getNamedInputs(nxJson: NxJsonConfiguration, project: ProjectGraphProjectNode): {
+    default: {
+        fileset: string;
+    }[];
+};
+export declare function getTargetInputs(nxJson: NxJsonConfiguration, projectNode: ProjectGraphProjectNode, target: string): {
+    selfInputs: string[];
+    dependencyInputs: string[];
+};
+export declare function extractPatternsFromFileSets(inputs: readonly ExpandedInput[]): string[];
+export declare function getInputs(task: Task, projectGraph: ProjectGraph, nxJson: NxJsonConfiguration): {
+    selfInputs: ExpandedSelfInput[];
+    depsInputs: {
+        input: string;
+        dependencies: true;
+    }[];
+    depsOutputs: ExpandedDepsOutput[];
+    projectInputs: {
+        input: string;
+        projects: string[];
+    }[];
+    depsFilesets: {
+        fileset: string;
+        dependencies: true;
+    }[];
+};
+export declare function splitInputsIntoSelfAndDependencies(inputs: ReadonlyArray<InputDefinition | string>, namedInputs: {
+    [inputName: string]: ReadonlyArray<InputDefinition | string>;
+}): {
+    depsInputs: {
+        input: string;
+        dependencies: true;
+    }[];
+    projectInputs: {
+        input: string;
+        projects: string[];
+    }[];
+    selfInputs: ExpandedSelfInput[];
+    depsOutputs: ExpandedDepsOutput[];
+    depsFilesets: {
+        fileset: string;
+        dependencies: true;
+    }[];
+};
+export declare function isSelfInput(input: ExpandedInput): input is ExpandedSelfInput;
+export declare function isDepsOutput(input: ExpandedInput): input is ExpandedDepsOutput;
+export declare function expandSingleProjectInputs(inputs: ReadonlyArray<InputDefinition | string>, namedInputs: {
+    [inputName: string]: ReadonlyArray<InputDefinition | string>;
+}): ExpandedInput[];
+export declare function expandNamedInput(input: string, namedInputs: {
+    [inputName: string]: ReadonlyArray<InputDefinition | string>;
+}): ExpandedInput[];
+export declare function filterUsingGlobPatterns(root: string, files: FileData[], patterns: string[]): FileData[];

package/dist/src/hasher/task-hasher.js

@@ -0,0 +1,299 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InProcessTaskHasher = exports.DaemonBasedTaskHasher = void 0;
+exports.getNamedInputs = getNamedInputs;
+exports.getTargetInputs = getTargetInputs;
+exports.extractPatternsFromFileSets = extractPatternsFromFileSets;
+exports.getInputs = getInputs;
+exports.splitInputsIntoSelfAndDependencies = splitInputsIntoSelfAndDependencies;
+exports.isSelfInput = isSelfInput;
+exports.isDepsOutput = isDepsOutput;
+exports.expandSingleProjectInputs = expandSingleProjectInputs;
+exports.expandNamedInput = expandNamedInput;
+exports.filterUsingGlobPatterns = filterUsingGlobPatterns;
+const file_hasher_1 = require("./file-hasher");
+const minimatch_1 = require("minimatch");
+const native_task_hasher_impl_1 = require("./native-task-hasher-impl");
+const workspace_root_1 = require("../utils/workspace-root");
+const task_io_service_1 = require("../tasks-runner/task-io-service");
+/**
+ * Normalize the legacy single-env `hashTasks(tasks, taskGraph, env)`
+ * signature to the per-task-env shape. External plugins still call the
+ * legacy shape, so `InProcessTaskHasher` and `DaemonBasedTaskHasher`
+ * detect at runtime and broadcast the shared env across every task.
+ *
+ * Detection is by value shape: `NodeJS.ProcessEnv` values are strings
+ * (or undefined), `perTaskEnvs` values are objects.
+ */
+function normalizePerTaskEnvs(tasks, arg) {
+    for (const value of Object.values(arg)) {
+        if (value === undefined)
+            continue;
+        if (typeof value === 'object') {
+            return arg;
+        }
+        // First defined value is a string — legacy env; broadcast it.
+        const env = arg;
+        const perTaskEnvs = {};
+        for (const task of tasks)
+            perTaskEnvs[task.id] = env;
+        return perTaskEnvs;
+    }
+    // Empty or all-undefined: treat as perTaskEnvs — safe because the
+    // Rust-side check will surface a clear error if entries are missing.
+    return arg;
+}
+class DaemonBasedTaskHasher {
+    constructor(daemonClient, runnerOptions) {
+        this.daemonClient = daemonClient;
+        this.runnerOptions = runnerOptions;
+    }
+    async hashTasks(tasks, taskGraph, envOrPerTaskEnvs) {
+        const collectInputs = (0, task_io_service_1.getTaskIOService)().hasTaskInputSubscribers();
+        return this.daemonClient.hashTasks(this.runnerOptions, tasks, taskGraph, normalizePerTaskEnvs(tasks, envOrPerTaskEnvs), process.cwd(), collectInputs);
+    }
+    async hashTask(task, taskGraph, env) {
+        return (await this.hashTasks([task], taskGraph, {
+            [task.id]: env ?? process.env,
+        }))[0];
+    }
+}
+exports.DaemonBasedTaskHasher = DaemonBasedTaskHasher;
+class InProcessTaskHasher {
+    constructor(projectGraph, nxJson, externalRustReferences, options) {
+        this.projectGraph = projectGraph;
+        this.nxJson = nxJson;
+        this.externalRustReferences = externalRustReferences;
+        this.options = options;
+        this.taskHasher = new native_task_hasher_impl_1.NativeTaskHasherImpl(workspace_root_1.workspaceRoot, this.nxJson, this.projectGraph, this.externalRustReferences, {
+            selectivelyHashTsConfig: this.options?.selectivelyHashTsConfig ?? false,
+        });
+    }
+    async hashTasks(tasks, taskGraph, envOrPerTaskEnvs, cwd, collectInputs) {
+        const hashes = await this.taskHasher.hashTasks(tasks, taskGraph, normalizePerTaskEnvs(tasks, envOrPerTaskEnvs), cwd ?? process.cwd(), collectInputs);
+        return tasks.map((task, index) => this.createHashDetails(task, hashes[index]));
+    }
+    async hashTask(task, taskGraph, env, cwd, collectInputs) {
+        const res = await this.taskHasher.hashTask(task, taskGraph, env ?? process.env, cwd ?? process.cwd(), collectInputs);
+        return this.createHashDetails(task, res);
+    }
+    createHashDetails(task, res) {
+        const command = this.hashCommand(task);
+        return {
+            value: (0, file_hasher_1.hashArray)([res.value, command]),
+            details: {
+                command,
+                nodes: res.details,
+                implicitDeps: {},
+                runtime: {},
+            },
+            inputs: res.inputs,
+        };
+    }
+    hashCommand(task) {
+        const overrides = { ...task.overrides };
+        delete overrides['__overrides_unparsed__'];
+        const sortedOverrides = {};
+        for (let k of Object.keys(overrides).sort()) {
+            sortedOverrides[k] = overrides[k];
+        }
+        return (0, file_hasher_1.hashArray)([
+            task.target.project ?? '',
+            task.target.target ?? '',
+            task.target.configuration ?? '',
+            JSON.stringify(sortedOverrides),
+        ]);
+    }
+}
+exports.InProcessTaskHasher = InProcessTaskHasher;
+const DEFAULT_INPUTS = [
+    {
+        input: 'default',
+    },
+    {
+        dependencies: true,
+        input: 'default',
+    },
+];
+function getNamedInputs(nxJson, project) {
+    return {
+        default: [{ fileset: '{projectRoot}/**/*' }],
+        ...nxJson.namedInputs,
+        ...project.data.namedInputs,
+    };
+}
+function getTargetInputs(nxJson, projectNode, target) {
+    const namedInputs = getNamedInputs(nxJson, projectNode);
+    const targetData = projectNode.data.targets[target];
+    const targetDefaults = (nxJson.targetDefaults || {})[target];
+    const inputs = splitInputsIntoSelfAndDependencies(targetData.inputs || targetDefaults?.inputs || DEFAULT_INPUTS, namedInputs);
+    const selfInputs = extractPatternsFromFileSets(inputs.selfInputs);
+    const dependencyInputs = [
+        ...extractPatternsFromFileSets(inputs.depsInputs
+            .map((s) => expandNamedInput(s.input, namedInputs))
+            .flat()),
+        ...inputs.depsFilesets.map((d) => d.fileset),
+    ];
+    return { selfInputs, dependencyInputs };
+}
+function extractPatternsFromFileSets(inputs) {
+    return inputs
+        .filter((c) => !!c['fileset'])
+        .map((c) => c['fileset']);
+}
+function getInputs(task, projectGraph, nxJson) {
+    const projectNode = projectGraph.nodes[task.target.project];
+    const namedInputs = getNamedInputs(nxJson, projectNode);
+    const targetData = projectNode.data.targets[task.target.target];
+    const targetDefaults = (nxJson.targetDefaults || {})[task.target.target];
+    const { selfInputs, depsInputs, depsOutputs, projectInputs, depsFilesets } = splitInputsIntoSelfAndDependencies(targetData.inputs || targetDefaults?.inputs || DEFAULT_INPUTS, namedInputs);
+    return { selfInputs, depsInputs, depsOutputs, projectInputs, depsFilesets };
+}
+function splitInputsIntoSelfAndDependencies(inputs, namedInputs) {
+    const depsInputs = [];
+    const projectInputs = [];
+    const depsFilesets = [];
+    const selfInputs = [];
+    for (const d of inputs) {
+        if (typeof d === 'string') {
+            if (d.startsWith('^')) {
+                const rest = d.substring(1);
+                if (rest.startsWith('{projectRoot}') ||
+                    rest.startsWith('{workspaceRoot}')) {
+                    depsFilesets.push({ fileset: rest, dependencies: true });
+                }
+                else {
+                    depsInputs.push({ input: rest, dependencies: true });
+                }
+            }
+            else {
+                selfInputs.push(d);
+            }
+        }
+        else {
+            if ('fileset' in d && 'dependencies' in d && d.dependencies) {
+                depsFilesets.push({
+                    fileset: d.fileset,
+                    dependencies: true,
+                });
+            }
+            else if ('input' in d &&
+                !('fileset' in d) &&
+                (('dependencies' in d && d.dependencies) ||
+                    // Todo(@AgentEnder): Remove check in v17
+                    ('projects' in d &&
+                        typeof d.projects === 'string' &&
+                        d.projects === 'dependencies'))) {
+                depsInputs.push({
+                    input: d.input,
+                    dependencies: true,
+                });
+            }
+            else if ('input' in d &&
+                !('fileset' in d) &&
+                'projects' in d &&
+                d.projects &&
+                // Todo(@AgentEnder): Remove check in v17
+                !(d.projects === 'self')) {
+                projectInputs.push({
+                    input: d.input,
+                    projects: Array.isArray(d.projects) ? d.projects : [d.projects],
+                });
+            }
+            else {
+                selfInputs.push(d);
+            }
+        }
+    }
+    const expandedInputs = expandSingleProjectInputs(selfInputs, namedInputs);
+    return {
+        depsInputs,
+        projectInputs,
+        selfInputs: expandedInputs.filter(isSelfInput),
+        depsOutputs: expandedInputs.filter(isDepsOutput),
+        depsFilesets,
+    };
+}
+function isSelfInput(input) {
+    return !('dependentTasksOutputFiles' in input);
+}
+function isDepsOutput(input) {
+    return 'dependentTasksOutputFiles' in input;
+}
+function expandSingleProjectInputs(inputs, namedInputs) {
+    const expanded = [];
+    for (const d of inputs) {
+        if (typeof d === 'string') {
+            if (d.startsWith('^'))
+                throw new Error(`namedInputs definitions cannot start with ^`);
+            if (namedInputs[d]) {
+                expanded.push(...expandNamedInput(d, namedInputs));
+            }
+            else {
+                expanded.push({ fileset: d });
+            }
+        }
+        else {
+            if (d.projects || d.dependencies) {
+                throw new Error(`namedInputs definitions can only refer to other namedInputs definitions within the same project.`);
+            }
+            if (d.fileset ||
+                d.env ||
+                d.runtime ||
+                d.externalDependencies ||
+                d.dependentTasksOutputFiles ||
+                d.workingDirectory ||
+                d.json) {
+                expanded.push(d);
+            }
+            else {
+                expanded.push(...expandNamedInput(d.input, namedInputs));
+            }
+        }
+    }
+    return expanded;
+}
+function expandNamedInput(input, namedInputs) {
+    namedInputs ||= {};
+    if (!namedInputs[input])
+        throw new Error(`Input '${input}' is not defined`);
+    return expandSingleProjectInputs(namedInputs[input], namedInputs);
+}
+function filterUsingGlobPatterns(root, files, patterns) {
+    const filesetWithExpandedProjectRoot = patterns
+        .map((f) => f.replace('{projectRoot}', root))
+        .map((r) => {
+        // handling root level projects that create './' pattern that doesn't work with minimatch
+        if (r.startsWith('./'))
+            return r.substring(2);
+        if (r.startsWith('!./'))
+            return '!' + r.substring(3);
+        return r;
+    });
+    const positive = [];
+    const negative = [];
+    for (const p of filesetWithExpandedProjectRoot) {
+        if (p.startsWith('!')) {
+            negative.push(p);
+        }
+        else {
+            positive.push(p);
+        }
+    }
+    if (positive.length === 0 && negative.length === 0) {
+        return files;
+    }
+    return files.filter((f) => {
+        let matchedPositive = false;
+        if (positive.length === 0 ||
+            (positive.length === 1 && positive[0] === `${root}/**/*`)) {
+            matchedPositive = true;
+        }
+        else {
+            matchedPositive = positive.some((pattern) => (0, minimatch_1.minimatch)(f.file, pattern));
+        }
+        if (!matchedPositive)
+            return false;
+        return negative.every((pattern) => (0, minimatch_1.minimatch)(f.file, pattern));
+    });
+}

package/dist/src/migrations/update-15-0-0/prefix-outputs.d.ts

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

package/dist/src/migrations/update-15-0-0/prefix-outputs.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = default_1;
+const format_changed_files_with_prettier_if_available_1 = require("../../generators/internal-utils/format-changed-files-with-prettier-if-available");
+const project_configuration_1 = require("../../generators/utils/project-configuration");
+const nx_json_1 = require("../../generators/utils/nx-json");
+const path_1 = require("path");
+const utils_1 = require("../../tasks-runner/utils");
+const json_1 = require("../../generators/utils/json");
+async function default_1(tree) {
+    // If the workspace doesn't have a nx.json, don't make any changes
+    if (!tree.exists('nx.json')) {
+        return;
+    }
+    const nxJson = (0, nx_json_1.readNxJson)(tree);
+    for (const [projectName, project] of (0, project_configuration_1.getProjects)(tree)) {
+        for (const [_, target] of Object.entries(project.targets ?? {})) {
+            if (!target.outputs) {
+                continue;
+            }
+            target.outputs = (0, utils_1.transformLegacyOutputs)(project.root, target.outputs);
+        }
+        try {
+            (0, project_configuration_1.updateProjectConfiguration)(tree, projectName, project);
+        }
+        catch {
+            if (tree.exists((0, path_1.join)(project.root, 'package.json'))) {
+                (0, json_1.updateJson)(tree, (0, path_1.join)(project.root, 'package.json'), (json) => {
+                    for (const target of Object.values(json.nx?.targets ?? {})) {
+                        if (target.outputs) {
+                            target.outputs = (0, utils_1.transformLegacyOutputs)(project.root, target.outputs);
+                        }
+                    }
+                    return json;
+                });
+            }
+        }
+    }
+    if (nxJson.targetDefaults) {
+        for (const [_, target] of Object.entries(nxJson.targetDefaults)) {
+            if (!target.outputs) {
+                continue;
+            }
+            target.outputs = (0, utils_1.transformLegacyOutputs)('{projectRoot}', target.outputs);
+        }
+        (0, nx_json_1.updateNxJson)(tree, nxJson);
+    }
+    await (0, format_changed_files_with_prettier_if_available_1.formatChangedFilesWithPrettierIfAvailable)(tree);
+}

package/dist/src/migrations/update-16-0-0/remove-nrwl-cli.d.ts

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

package/dist/src/migrations/update-16-0-0/remove-nrwl-cli.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = default_1;
+const format_changed_files_with_prettier_if_available_1 = require("../../generators/internal-utils/format-changed-files-with-prettier-if-available");
+const json_1 = require("../../generators/utils/json");
+async function default_1(tree) {
+    (0, json_1.updateJson)(tree, 'package.json', (json) => {
+        for (const deps of [json.dependencies, json.devDependencies]) {
+            if (deps) {
+                delete deps['@nrwl/cli'];
+            }
+        }
+        return json;
+    });
+    await (0, format_changed_files_with_prettier_if_available_1.formatChangedFilesWithPrettierIfAvailable)(tree);
+}

package/dist/src/migrations/update-16-0-0/update-depends-on-to-tokens.d.ts

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

package/dist/src/migrations/update-16-0-0/update-depends-on-to-tokens.js

@@ -0,0 +1,97 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = default_1;
+const project_configuration_1 = require("../../generators/utils/project-configuration");
+const format_changed_files_with_prettier_if_available_1 = require("../../generators/internal-utils/format-changed-files-with-prettier-if-available");
+async function default_1(tree) {
+    updateDependsOnAndInputsInsideNxJson(tree);
+    const projectsConfigurations = (0, project_configuration_1.getProjects)(tree);
+    for (const [projectName, projectConfiguration] of projectsConfigurations) {
+        let projectChanged = false;
+        for (const [targetName, targetConfiguration] of Object.entries(projectConfiguration.targets ?? {})) {
+            for (const dependency of targetConfiguration.dependsOn ?? []) {
+                if (typeof dependency !== 'string') {
+                    if (dependency.projects === 'self' ||
+                        dependency.projects === '{self}') {
+                        delete dependency.projects;
+                        projectChanged = true;
+                    }
+                    else if (dependency.projects === 'dependencies' ||
+                        dependency.projects === '{dependencies}') {
+                        delete dependency.projects;
+                        dependency.dependencies = true;
+                        projectChanged = true;
+                    }
+                }
+            }
+            for (let i = 0; i < (targetConfiguration.inputs?.length ?? 0); i++) {
+                const input = targetConfiguration.inputs[i];
+                if (typeof input !== 'string') {
+                    if ('projects' in input &&
+                        (input.projects === 'self' || input.projects === '{self}')) {
+                        delete input.projects;
+                        projectChanged = true;
+                    }
+                    else if ('projects' in input &&
+                        (input.projects === 'dependencies' ||
+                            input.projects === '{dependencies}')) {
+                        delete input.projects;
+                        targetConfiguration.inputs[i] = {
+                            ...input,
+                            dependencies: true,
+                        };
+                        projectChanged = true;
+                    }
+                }
+            }
+        }
+        if (projectChanged) {
+            (0, project_configuration_1.updateProjectConfiguration)(tree, projectName, projectConfiguration);
+        }
+    }
+    await (0, format_changed_files_with_prettier_if_available_1.formatChangedFilesWithPrettierIfAvailable)(tree);
+}
+function updateDependsOnAndInputsInsideNxJson(tree) {
+    const nxJson = (0, project_configuration_1.readNxJson)(tree);
+    let nxJsonChanged = false;
+    for (const [target, defaults] of Object.entries(nxJson?.targetDefaults ?? {})) {
+        for (const dependency of defaults.dependsOn ?? []) {
+            if (typeof dependency !== 'string') {
+                if (dependency.projects === 'self' ||
+                    dependency.projects === '{self}') {
+                    delete dependency.projects;
+                    nxJsonChanged = true;
+                }
+                else if (dependency.projects === 'dependencies' ||
+                    dependency.projects === '{dependencies}') {
+                    delete dependency.projects;
+                    dependency.dependencies = true;
+                    nxJsonChanged = true;
+                }
+            }
+        }
+        for (let i = 0; i < (defaults.inputs?.length ?? 0); i++) {
+            const input = defaults.inputs[i];
+            if (typeof input !== 'string') {
+                if ('projects' in input &&
+                    (input.projects === 'self' || input.projects === '{self}')) {
+                    delete input.projects;
+                    nxJsonChanged = true;
+                }
+                else if ('projects' in input &&
+                    (input.projects === 'dependencies' ||
+                        input.projects === '{dependencies}')) {
+                    delete input.projects;
+                    defaults.inputs[i] = {
+                        ...input,
+                        dependencies: true,
+                    };
+                    nxJsonChanged = true;
+                }
+            }
+        }
+    }
+    if (nxJsonChanged) {
+        (0, project_configuration_1.updateNxJson)(tree, nxJson);
+    }
+}

package/dist/src/migrations/update-16-0-0/update-nx-cloud-runner.d.ts

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