nx 17.0.3 → 17.0.5

package/src/generators/testing-utils/create-tree-with-empty-workspace.js

@@ -35,12 +35,6 @@ function addCommonFiles(tree, addAppsAndLibsFolders) {
             lint: {
                 cache: true,
             },
-            test: {
-                cache: true,
-            },
-            e2e: {
-                cache: true,
-            },
         },
     }));
     tree.write('/tsconfig.base.json', JSON.stringify({ compilerOptions: { paths: {} } }));

package/src/generators/tree.d.ts

@@ -1,4 +1,5 @@
 /// <reference types="node" />
+/// <reference types="@types/node/ts4.8/fs" />
 /// <reference types="node" />
 import type { Mode } from 'fs';
 /**

package/src/generators/utils/glob.js

@@ -1,9 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.glob = void 0;
+const minimatch_1 = require("minimatch");
 const globs_1 = require("../../utils/globs");
 const workspace_context_1 = require("../../utils/workspace-context");
-const minimatch = require("minimatch");
 /**
  * Performs a tree-aware glob search on the files in a workspace. Able to find newly
  * created files and hides deleted files before the updates are committed to disk.
@@ -16,7 +16,7 @@ const minimatch = require("minimatch");
 function glob(tree, patterns) {
     const matches = new Set((0, workspace_context_1.globWithWorkspaceContext)(tree.root, patterns));
     const combinedGlob = (0, globs_1.combineGlobPatterns)(patterns);
-    const matcher = minimatch.makeRe(combinedGlob);
+    const matcher = minimatch_1.minimatch.makeRe(combinedGlob);
     if (!matcher) {
         throw new Error('Invalid glob pattern: ' + combinedGlob);
     }

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

@@ -1,17 +1,18 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getRelativeProjectJsonSchemaPath = exports.getProjects = exports.readProjectConfiguration = exports.removeProjectConfiguration = exports.updateProjectConfiguration = exports.addProjectConfiguration = exports.updateNxJson = exports.readNxJson = void 0;
+const minimatch_1 = require("minimatch");
 const path_1 = require("path");
-const package_json_workspaces_1 = require("../../../plugins/package-json-workspaces");
+const package_json_workspaces_1 = require("../../plugins/package-json-workspaces");
 const project_json_1 = require("../../plugins/project-json/build-nodes/project-json");
 const angular_json_1 = require("../../adapter/angular-json");
 const project_configuration_utils_1 = require("../../project-graph/utils/project-configuration-utils");
 const retrieve_workspace_files_1 = require("../../project-graph/utils/retrieve-workspace-files");
+const workspace_context_1 = require("../../utils/workspace-context");
 const output_1 = require("../../utils/output");
 const path_2 = require("../../utils/path");
 const json_1 = require("./json");
 const nx_json_1 = require("./nx-json");
-const minimatch = require("minimatch");
 var nx_json_2 = require("./nx-json");
 Object.defineProperty(exports, "readNxJson", { enumerable: true, get: function () { return nx_json_2.readNxJson; } });
 Object.defineProperty(exports, "updateNxJson", { enumerable: true, get: function () { return nx_json_2.updateNxJson; } });
@@ -31,9 +32,10 @@ function addProjectConfiguration(tree, projectName, projectConfiguration, standa
         });
     }
     if (tree.exists(projectConfigFile)) {
-        throw new Error(`Cannot create a new project ${projectName} at ${projectConfiguration.root}. It already exists.`);
+        throw new Error(`Cannot create a new project ${projectName} at ${projectConfiguration.root}. A project already exists in this directory.`);
     }
     delete projectConfiguration.$schema;
+    handleEmptyTargets(projectName, projectConfiguration);
     (0, json_1.writeJson)(tree, projectConfigFile, {
         name: projectName,
         $schema: getRelativeProjectJsonSchemaPath(tree, projectConfiguration),
@@ -54,6 +56,7 @@ function updateProjectConfiguration(tree, projectName, projectConfiguration) {
     if (!tree.exists(projectConfigFile)) {
         throw new Error(`Cannot update Project ${projectName} at ${projectConfiguration.root}. It either doesn't exist yet, or may not use project.json for configuration. Use \`addProjectConfiguration()\` instead if you want to create a new project.`);
     }
+    handleEmptyTargets(projectName, projectConfiguration);
     (0, json_1.writeJson)(tree, projectConfigFile, {
         name: projectConfiguration.name ?? projectName,
         $schema: getRelativeProjectJsonSchemaPath(tree, projectConfiguration),
@@ -130,9 +133,13 @@ function readAndCombineAllProjectConfigurations(tree) {
     const patterns = [
         '**/project.json',
         'project.json',
-        ...(0, package_json_workspaces_1.getGlobPatternsFromPackageManagerWorkspaces)(tree.root, (p) => (0, json_1.readJson)(tree, p)),
+        ...(0, package_json_workspaces_1.getGlobPatternsFromPackageManagerWorkspaces)(tree.root, (p) => (0, json_1.readJson)(tree, p, { expectComments: true })),
     ];
-    const globbedFiles = (0, retrieve_workspace_files_1.retrieveProjectConfigurationPathsWithoutPluginInference)(tree.root);
+    const projectGlobPatterns = (0, retrieve_workspace_files_1.configurationGlobs)([
+        { plugin: project_json_1.ProjectJsonProjectsPlugin },
+        { plugin: (0, package_json_workspaces_1.getNxPackageJsonWorkspacesPlugin)(tree.root) },
+    ]);
+    const globbedFiles = (0, workspace_context_1.globWithWorkspaceContext)(tree.root, projectGlobPatterns);
     const createdFiles = findCreatedProjectFiles(tree, patterns);
     const deletedFiles = findDeletedProjectFiles(tree, patterns);
     const projectFiles = [...globbedFiles, ...createdFiles].filter((r) => deletedFiles.indexOf(r) === -1);
@@ -141,7 +148,7 @@ function readAndCombineAllProjectConfigurations(tree) {
         if ((0, path_1.basename)(projectFile) === 'project.json') {
             const json = (0, json_1.readJson)(tree, projectFile);
             const config = (0, project_json_1.buildProjectFromProjectJson)(json, projectFile);
-            (0, project_configuration_utils_1.mergeProjectConfigurationIntoRootMap)(rootMap, config);
+            (0, project_configuration_utils_1.mergeProjectConfigurationIntoRootMap)(rootMap, config, undefined, undefined, true);
         }
         else if ((0, path_1.basename)(projectFile) === 'package.json') {
             const packageJson = (0, json_1.readJson)(tree, projectFile);
@@ -153,7 +160,7 @@ function readAndCombineAllProjectConfigurations(tree) {
                 {
                     name: config.name,
                     root: config.root,
-                });
+                }, undefined, undefined, true);
             }
         }
     }
@@ -173,7 +180,7 @@ function findCreatedProjectFiles(tree, globPatterns) {
     for (const change of tree.listChanges()) {
         if (change.type === 'CREATE') {
             const fileName = (0, path_1.basename)(change.path);
-            if (globPatterns.some((pattern) => minimatch(change.path, pattern, { dot: true }))) {
+            if (globPatterns.some((pattern) => (0, minimatch_1.minimatch)(change.path, pattern, { dot: true }))) {
                 createdProjectFiles.push(change.path);
             }
             else if (fileName === 'package.json') {
@@ -200,7 +207,7 @@ function findDeletedProjectFiles(tree, globPatterns) {
         .listChanges()
         .filter((f) => {
         return (f.type === 'DELETE' &&
-            globPatterns.some((pattern) => minimatch(f.path, pattern)));
+            globPatterns.some((pattern) => (0, minimatch_1.minimatch)(f.path, pattern)));
     })
         .map((r) => r.path);
 }
@@ -232,3 +239,15 @@ function toNewFormat(w) {
     }
     return w;
 }
+function handleEmptyTargets(projectName, projectConfiguration) {
+    if (projectConfiguration.targets &&
+        !Object.keys(projectConfiguration.targets).length) {
+        // Re-order `targets` to appear after the `// target` comment.
+        delete projectConfiguration.targets;
+        projectConfiguration['// targets'] = `to see all targets run: nx show project ${projectName} --web`;
+        projectConfiguration.targets = {};
+    }
+    else {
+        delete projectConfiguration['// targets'];
+    }
+}

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

@@ -0,0 +1,4 @@
+import { NxJsonConfiguration } from '../config/nx-json';
+import { ProjectGraph } from '../config/project-graph';
+import { TaskHasher } from './task-hasher';
+export declare function createTaskHasher(projectGraph: ProjectGraph, nxJson: NxJsonConfiguration, runnerOptions?: any): TaskHasher;

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

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createTaskHasher = void 0;
+const client_1 = require("../daemon/client/client");
+const build_project_graph_1 = require("../project-graph/build-project-graph");
+const task_hasher_1 = require("./task-hasher");
+function createTaskHasher(projectGraph, nxJson, runnerOptions) {
+    if (client_1.daemonClient.enabled()) {
+        return new task_hasher_1.DaemonBasedTaskHasher(client_1.daemonClient, runnerOptions);
+    }
+    else {
+        const { fileMap, allWorkspaceFiles, rustReferences } = (0, build_project_graph_1.getFileMap)();
+        return new task_hasher_1.InProcessTaskHasher(fileMap?.projectFileMap, allWorkspaceFiles, projectGraph, nxJson, rustReferences, runnerOptions);
+    }
+}
+exports.createTaskHasher = createTaskHasher;

package/src/hasher/hash-task.js

@@ -6,9 +6,10 @@ const project_graph_1 = require("../project-graph/project-graph");
 const task_hasher_1 = require("./task-hasher");
 const nx_json_1 = require("../config/nx-json");
 async function hashTasksThatDoNotDependOnOutputsOfOtherTasks(hasher, projectGraph, taskGraph, nxJson) {
+    performance.mark('hashMultipleTasks:start');
     const tasks = Object.values(taskGraph.tasks);
     const tasksWithHashers = await Promise.all(tasks.map(async (task) => {
-        const customHasher = await (0, utils_1.getCustomHasher)(task, projectGraph);
+        const customHasher = (0, utils_1.getCustomHasher)(task, projectGraph);
         return { task, customHasher };
     }));
     const tasksToHash = tasksWithHashers
@@ -26,17 +27,20 @@ async function hashTasksThatDoNotDependOnOutputsOfOtherTasks(hasher, projectGrap
         tasksToHash[i].hash = hashes[i].value;
         tasksToHash[i].hashDetails = hashes[i].details;
     }
+    performance.mark('hashMultipleTasks:end');
+    performance.measure('hashMultipleTasks', 'hashMultipleTasks:start', 'hashMultipleTasks:end');
 }
 exports.hashTasksThatDoNotDependOnOutputsOfOtherTasks = hashTasksThatDoNotDependOnOutputsOfOtherTasks;
 async function hashTask(hasher, projectGraph, taskGraph, task, env) {
-    const customHasher = await (0, utils_1.getCustomHasher)(task, projectGraph);
+    performance.mark('hashSingleTask:start');
+    const customHasher = (0, utils_1.getCustomHasher)(task, projectGraph);
     const projectsConfigurations = (0, project_graph_1.readProjectsConfigurationFromProjectGraph)(projectGraph);
     const { value, details } = await (customHasher
         ? customHasher(task, {
             hasher,
             projectGraph,
             taskGraph,
-            workspaceConfig: projectsConfigurations,
+            workspaceConfig: projectsConfigurations, // to make the change non-breaking. Remove after v19
             projectsConfigurations,
             nxJsonConfiguration: (0, nx_json_1.readNxJson)(),
             env,
@@ -44,5 +48,7 @@ async function hashTask(hasher, projectGraph, taskGraph, task, env) {
         : hasher.hashTask(task, taskGraph, env));
     task.hash = value;
     task.hashDetails = details;
+    performance.mark('hashSingleTask:end');
+    performance.measure('hashSingleTask', 'hashSingleTask:start', 'hashSingleTask:end');
 }
 exports.hashTask = hashTask;

package/src/hasher/native-task-hasher-impl.d.ts

@@ -0,0 +1,19 @@
+/// <reference types="node" />
+import { NxJsonConfiguration } from '../config/nx-json';
+import { ProjectGraph } from '../config/project-graph';
+import { Task, TaskGraph } from '../config/task-graph';
+import { ExternalObject, FileData, HasherOptions, HashPlanner, NxWorkspaceFilesExternals, ProjectGraph as NativeProjectGraph, TaskHasher } from '../native';
+import { PartialHash, TaskHasherImpl } from './task-hasher';
+export declare class NativeTaskHasherImpl implements TaskHasherImpl {
+    hasher: TaskHasher;
+    planner: HashPlanner;
+    projectGraphRef: ExternalObject<NativeProjectGraph>;
+    allWorkspaceFilesRef: ExternalObject<FileData[]>;
+    projectFileMapRef: ExternalObject<Record<string, FileData[]>>;
+    options: HasherOptions | undefined;
+    constructor(workspaceRoot: string, nxJson: NxJsonConfiguration, projectGraph: ProjectGraph, externals: NxWorkspaceFilesExternals, options: {
+        selectivelyHashTsConfig: boolean;
+    });
+    hashTask(task: Task, taskGraph: TaskGraph, env: NodeJS.ProcessEnv): Promise<PartialHash>;
+    hashTasks(tasks: Task[], taskGraph: TaskGraph, env: NodeJS.ProcessEnv): Promise<PartialHash[]>;
+}

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

@@ -0,0 +1,37 @@
+"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 fileutils_1 = require("../utils/fileutils");
+const typescript_1 = require("../plugins/js/utils/typescript");
+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, options);
+    }
+    async hashTask(task, taskGraph, env) {
+        const plans = this.planner.getPlansReference([task.id], taskGraph);
+        const hashes = this.hasher.hashPlans(plans, env);
+        return hashes[task.id];
+    }
+    async hashTasks(tasks, taskGraph, env) {
+        const plans = this.planner.getPlansReference(tasks.map((t) => t.id), taskGraph);
+        const hashes = this.hasher.hashPlans(plans, env);
+        return tasks.map((t) => hashes[t.id]);
+    }
+}
+exports.NativeTaskHasherImpl = NativeTaskHasherImpl;

package/src/hasher/node-task-hasher-impl.d.ts

@@ -0,0 +1,49 @@
+/// <reference types="node" />
+import { NxJsonConfiguration } from '../config/nx-json';
+import { FileData, ProjectFileMap, ProjectGraph } from '../config/project-graph';
+import { Task, TaskGraph } from '../config/task-graph';
+import { PartialHash, TaskHasherImpl } from './task-hasher';
+export declare class NodeTaskHasherImpl implements TaskHasherImpl {
+    private readonly nxJson;
+    private readonly legacyRuntimeInputs;
+    private readonly legacyFilesetInputs;
+    private readonly projectFileMap;
+    private readonly allWorkspaceFiles;
+    private readonly projectGraph;
+    private readonly options;
+    private filesetHashes;
+    private runtimeHashes;
+    private externalDependencyHashes;
+    private allExternalDependenciesHash;
+    private projectRootMappings;
+    constructor(nxJson: NxJsonConfiguration, legacyRuntimeInputs: {
+        runtime: string;
+    }[], legacyFilesetInputs: {
+        fileset: string;
+    }[], projectFileMap: ProjectFileMap, allWorkspaceFiles: FileData[], projectGraph: ProjectGraph, options: {
+        selectivelyHashTsConfig: boolean;
+    });
+    hashTasks(tasks: Task[], taskGraph: TaskGraph, env: NodeJS.ProcessEnv): Promise<PartialHash[]>;
+    hashTask(task: Task, taskGraph: TaskGraph, env: NodeJS.ProcessEnv, visited?: string[]): Promise<PartialHash>;
+    private hashNamedInputForDependencies;
+    private hashSelfAndDepsInputs;
+    private combinePartialHashes;
+    private hashDepsInputs;
+    private hashDepsOutputs;
+    private hashDepOuputs;
+    private hashFiles;
+    private getExternalDependencyHash;
+    private hashSingleExternalDependency;
+    private hashExternalDependency;
+    private hashTarget;
+    private findExternalDependencyNodeName;
+    private hashSingleProjectInputs;
+    private hashProjectInputs;
+    private hashRootFileset;
+    private hashProjectConfig;
+    private hashTsConfig;
+    private hashProjectFileset;
+    private hashRuntime;
+    private hashEnv;
+    private calculateExternalDependencyHashes;
+}