chore(misc): address review feedback

packages/nx/src/command-line/run-many.spec.ts

@@ -139,7 +139,7 @@ describe('run-many', () => {
         );
         performance.mark('end');
         const measure = performance.measure('projects', 'start', 'end');
-        expect(measure.duration).toBeLessThan(2500);
+        expect(measure.duration).toBeLessThan(3000);
       });
     });
   });

packages/nx/src/command-line/run-many.ts

@@ -58,7 +58,6 @@ export function projectsToRun(
 ): ProjectGraphProjectNode[] {
   const selectedProjects = new Map<string, ProjectGraphProjectNode>();
   const validProjects = runnableForTarget(projectGraph.nodes, nxArgs.targets);
-  const validProjectNames = Array.from(validProjects.keys());
   const invalidProjects: string[] = [];
 
   // --all is default now, if --projects is provided, it'll override the --all
@@ -67,9 +66,11 @@ export function projectsToRun(
       selectedProjects.set(projectName, projectGraph.nodes[projectName]);
     }
   } else {
+    const allProjectNames = Object.keys(projectGraph.nodes);
     const matchingProjects = findMatchingProjects(
       nxArgs.projects,
-      Object.keys(projectGraph.nodes)
+      allProjectNames,
+      new Set(allProjectNames)
     );
     for (const project of matchingProjects) {
       if (!validProjects.has(project)) {
@@ -93,7 +94,8 @@ export function projectsToRun(
 
   const excludedProjects = findMatchingProjects(
     nxArgs.exclude ?? [],
-    Array.from(selectedProjects.keys())
+    Array.from(selectedProjects.keys()),
+    new Set(selectedProjects.keys())
   );
 
   for (const excludedProject of excludedProjects) {

packages/nx/src/project-graph/build-nodes/workspace-projects.spec.ts

@@ -1,70 +1,46 @@
-import { ProjectConfiguration } from 'nx/src/config/workspace-json-project-json';
 import { normalizeImplicitDependencies } from './workspace-projects';
 
 describe('workspace-projects', () => {
+  let projectsSet: Set<string>;
+
+  beforeEach(() => {
+    projectsSet = new Set(['test-project', 'a', 'b', 'c']);
+  });
+
   describe('normalizeImplicitDependencies', () => {
     it('should expand "*" implicit dependencies', () => {
       expect(
-        normalizeImplicitDependencies('test-project', ['*'], {
-          fileMap: {},
-          filesToProcess: {},
-          workspace: {
-            version: 2,
-            projects: {
-              ...makeProject('test-project'),
-              ...makeProject('a'),
-              ...makeProject('b'),
-              ...makeProject('c'),
-            },
-          },
-        })
+        normalizeImplicitDependencies(
+          'test-project',
+          ['*'],
+          Array.from(projectsSet),
+          projectsSet
+        )
       ).toEqual(['a', 'b', 'c']);
     });
 
     it('should return [] for null implicit dependencies', () => {
       expect(
-        normalizeImplicitDependencies('test-project', null, {
-          fileMap: {},
-          filesToProcess: {},
-          workspace: {
-            version: 2,
-            projects: {
-              ...makeProject('test-project'),
-              ...makeProject('a'),
-              ...makeProject('b'),
-              ...makeProject('c'),
-            },
-          },
-        })
+        normalizeImplicitDependencies(
+          'test-project',
+          null,
+          Array.from(projectsSet),
+          projectsSet
+        )
       ).toEqual([]);
     });
 
     it('should expand glob based implicit dependencies', () => {
+      projectsSet.add('b-1');
+      projectsSet.add('b-2');
       expect(
-        normalizeImplicitDependencies('test-project', ['b*'], {
-          fileMap: {},
-          filesToProcess: {},
-          workspace: {
-            version: 2,
-            projects: {
-              ...makeProject('test-project'),
-              ...makeProject('a'),
-              ...makeProject('b'),
-              ...makeProject('b-1'),
-              ...makeProject('b-2'),
-              ...makeProject('c'),
-            },
-          },
-        })
+        normalizeImplicitDependencies(
+          'test-project',
+          ['b*'],
+          Array.from(projectsSet),
+          projectsSet
+        )
       ).toEqual(['b', 'b-1', 'b-2']);
     });
   });
 });
-
-function makeProject(name: string): Record<string, ProjectConfiguration> {
-  return {
-    [name]: {
-      root: `packages/${name}`,
-    },
-  };
-}

packages/nx/src/project-graph/build-nodes/workspace-projects.ts

@@ -24,7 +24,10 @@ export function buildWorkspaceProjectNodes(
   nxJson: NxJsonConfiguration
 ) {
   const toAdd = [];
-  Object.keys(ctx.workspace.projects).forEach((key) => {
+  const projects = Object.keys(ctx.workspace.projects);
+  const projectsSet = new Set(projects);
+
+  for (const key of projects) {
     const p = ctx.workspace.projects[key];
     const projectRoot = join(workspaceRoot, p.root);
 
@@ -56,7 +59,8 @@ export function buildWorkspaceProjectNodes(
     p.implicitDependencies = normalizeImplicitDependencies(
       key,
       p.implicitDependencies,
-      ctx
+      projects,
+      projectsSet
     );
 
     p.targets = mergePluginTargetsWithNxTargets(
@@ -83,7 +87,7 @@ export function buildWorkspaceProjectNodes(
         files: ctx.fileMap[key],
       },
     });
-  });
+  }
 
   // Sort by root directory length (do we need this?)
   toAdd.sort((a, b) => {
@@ -149,12 +153,16 @@ function normalizeProjectTargets(
 export function normalizeImplicitDependencies(
   source: string,
   implicitDependencies: ProjectConfiguration['implicitDependencies'],
-  context: ProjectGraphProcessorContext
+  projectNames: string[],
+  projectsSet: Set<string>
 ) {
-  return findMatchingProjects(
-    implicitDependencies || [],
-    Object.keys(context.workspace.projects).filter(
-      (projectName) => projectName !== source
-    )
+  if (!implicitDependencies?.length) {
+    return implicitDependencies ?? [];
+  }
+  const matches = findMatchingProjects(
+    implicitDependencies,
+    projectNames,
+    projectsSet
   );
+  return matches.filter((x) => x !== source);
 }

packages/nx/src/utils/assert-workspace-validity.ts

@@ -10,7 +10,8 @@ export function assertWorkspaceValidity(
   workspaceJson,
   nxJson: NxJsonConfiguration
 ) {
-  const workspaceJsonProjects = Object.keys(workspaceJson.projects);
+  const projectNames = Object.keys(workspaceJson.projects);
+  const projectNameSet = new Set(projectNames);
 
   const projects = {
     ...workspaceJson.projects,
@@ -50,12 +51,14 @@ export function assertWorkspaceValidity(
         map,
         filename,
         projectNames,
-        projects
+        projects,
+        projectNames,
+        projectNameSet
       );
       return map;
     }, invalidImplicitDependencies);
 
-  workspaceJsonProjects
+  projectNames
     .filter((projectName) => {
       const project = projects[projectName];
       return !!project.implicitDependencies;
@@ -66,7 +69,9 @@ export function assertWorkspaceValidity(
         map,
         projectName,
         project.implicitDependencies,
-        projects
+        projects,
+        projectNames,
+        projectNameSet
       );
       return map;
     }, invalidImplicitDependencies);
@@ -91,17 +96,18 @@ function detectAndSetInvalidProjectGlobValues(
   map: Map<string, string[]>,
   sourceName: string,
   desiredImplicitDeps: string[],
-  validProjects: ProjectsConfigurations['projects']
+  projectConfigurations: ProjectsConfigurations['projects'],
+  projectNames: string[],
+  projectNameSet: Set<string>
 ) {
-  const validProjectNames = Object.keys(validProjects);
   const invalidProjectsOrGlobs = desiredImplicitDeps.filter((implicit) => {
     const projectName = implicit.startsWith('!')
       ? implicit.substring(1)
       : implicit;
 
     return !(
-      validProjects[projectName] ||
-      findMatchingProjects([implicit], validProjectNames).length
+      projectConfigurations[projectName] ||
+      findMatchingProjects([implicit], projectNames, projectNameSet).length
     );
   });
 

packages/nx/src/utils/find-matching-projects.spec.ts

@@ -0,0 +1,30 @@
+import { findMatchingProjects } from './find-matching-projects';
+
+describe('findMatchingProjects', () => {
+  let projectsSet: Set<string>;
+
+  beforeEach(() => {
+    projectsSet = new Set(['test-project', 'a', 'b', 'c']);
+  });
+
+  it('should expand "*"', () => {
+    expect(
+      findMatchingProjects(['*'], Array.from(projectsSet), projectsSet)
+    ).toEqual(['test-project', 'a', 'b', 'c']);
+  });
+
+  it('should expand generic glob patterns', () => {
+    projectsSet.add('b-1');
+    projectsSet.add('b-2');
+
+    expect(
+      findMatchingProjects(['b*'], Array.from(projectsSet), projectsSet)
+    ).toEqual(['b', 'b-1', 'b-2']);
+  });
+
+  it('should support projectNames', () => {
+    expect(
+      findMatchingProjects(['a', 'b'], Array.from(projectsSet), projectsSet)
+    ).toEqual(['a', 'b']);
+  });
+});

packages/nx/src/utils/find-matching-projects.ts

@@ -1,18 +1,33 @@
 import minimatch = require('minimatch');
 
+const globCharacters = ['*', '|', '{', '}', '(', ')'];
+
+/**
+ * Find matching project names given a list of potential project names or globs.
+ *
+ * @param patterns A list of project names or globs to match against.
+ * @param projectNames An array containing the list of project names.
+ * @param projectNamesSet A set containing the list of project names.
+ * @returns
+ */
 export function findMatchingProjects(
   patterns: string[],
-  projectNames: string[]
+  projectNames: string[],
+  projectNamesSet: Set<string>
 ): string[] {
   const selectedProjects: Set<string> = new Set();
   const excludedProjects: Set<string> = new Set();
 
   for (const nameOrGlob of patterns) {
-    if (projectNames.includes(nameOrGlob)) {
+    if (projectNamesSet.has(nameOrGlob)) {
       selectedProjects.add(nameOrGlob);
       continue;
     }
 
+    if (!globCharacters.some((c) => nameOrGlob.includes(c))) {
+      continue;
+    }
+
     const exclude = nameOrGlob.startsWith('!');
     const pattern = exclude ? nameOrGlob.substring(1) : nameOrGlob;