feat(core): optimize project locator perf

Author: FrozenPandaz

Diff for: packages/workspace/src/core/project-graph/build-dependencies/explicit-project-dependencies.ts

@@ -14,7 +14,7 @@ export function buildExplicitTypeScriptDependencies(
   fileRead: (s: string) => string
 ) {
   const importLocator = new TypeScriptImportLocator(fileRead);
-  const targetProjectLocator = new TargetProjectLocator(nodes);
+  const targetProjectLocator = new TargetProjectLocator(nodes, fileRead);
   Object.keys(ctx.fileMap).forEach((source) => {
     Object.values(ctx.fileMap[source]).forEach((f) => {
       importLocator.fromFile(

Diff for: packages/workspace/src/core/target-project-locator.spec.ts

@@ -1,5 +1,4 @@
 import { fs, vol } from 'memfs';
-import { join } from 'path';
 import {
   ProjectGraphContext,
   ProjectGraphNode,
@@ -197,6 +196,34 @@ describe('findTargetProjectWithImport', () => {
     targetProjectLocator = new TargetProjectLocator(projects);
   });
 
+  it('should be able to resolve a module by using relative paths', () => {
+    const res1 = targetProjectLocator.findProjectWithImport(
+      './class.ts',
+      'libs/proj/index.ts',
+      ctx.nxJson.npmScope
+    );
+    const res2 = targetProjectLocator.findProjectWithImport(
+      '../index.ts',
+      'libs/proj/src/index.ts',
+      ctx.nxJson.npmScope
+    );
+    const res3 = targetProjectLocator.findProjectWithImport(
+      '../proj/../proj2/index.ts',
+      'libs/proj/index.ts',
+      ctx.nxJson.npmScope
+    );
+    const res4 = targetProjectLocator.findProjectWithImport(
+      '../proj/../index.ts',
+      'libs/proj/src/index.ts',
+      ctx.nxJson.npmScope
+    );
+
+    expect(res1).toEqual('proj');
+    expect(res2).toEqual('proj');
+    expect(res3).toEqual('proj2');
+    expect(res4).toEqual('proj');
+  });
+
   it('should be able to resolve a module by using tsConfig paths', () => {
     const proj2 = targetProjectLocator.findProjectWithImport(
       '@proj/my-second-proj',
@@ -243,19 +270,4 @@ describe('findTargetProjectWithImport', () => {
     );
     expect(parentProj).toEqual('proj1234');
   });
-
-  it('should be able to sort graph nodes', () => {
-    expect(targetProjectLocator._sortedNodeNames).toEqual([
-      'proj1234-child',
-      'proj1234',
-      'proj123',
-      'proj4ab',
-      'proj3a',
-      'proj2',
-      'proj',
-      '@ng/core',
-      '@ng/common',
-      'npm-package',
-    ]);
-  });
 });

Diff for: packages/workspace/src/core/target-project-locator.ts

@@ -1,15 +1,29 @@
 import { resolveModuleByImport } from '../utils/typescript';
-import { normalizedProjectRoot } from './file-utils';
+import { defaultFileRead, normalizedProjectRoot } from './file-utils';
 import { ProjectGraphNodeRecords } from './project-graph/project-graph-models';
 import { getSortedProjectNodes, isWorkspaceProject } from './project-graph';
+import { isRelativePath, parseJsonWithComments } from '../utils/fileutils';
+import { dirname, join } from 'path';
 
 export class TargetProjectLocator {
-  _sortedNodeNames = [];
+  private sortedWorkspaceProjects = [];
+  private paths = parseJsonWithComments(this.fileRead(`./tsconfig.base.json`))
+    ?.compilerOptions?.paths;
+  private cache = new Map<string, string>();
 
-  constructor(private nodes: ProjectGraphNodeRecords) {
-    this._sortedNodeNames = getSortedProjectNodes(nodes).map(
-      ({ name }) => name
-    );
+  constructor(
+    private nodes: ProjectGraphNodeRecords,
+    private fileRead: (path: string) => string = defaultFileRead
+  ) {
+    this.sortedWorkspaceProjects = getSortedProjectNodes(nodes)
+      .filter((node) => isWorkspaceProject(node))
+      .map((node) => ({
+        ...node,
+        data: {
+          ...node.data,
+          normalizedRoot: normalizedProjectRoot(node),
+        },
+      }));
   }
 
   /**
@@ -27,28 +41,45 @@ export class TargetProjectLocator {
     importExpr: string,
     filePath: string,
     npmScope: string
-  ) {
+  ): string {
     const normalizedImportExpr = importExpr.split('#')[0];
 
-    const resolvedModule = resolveModuleByImport(
-      normalizedImportExpr,
-      filePath
-    );
-
-    return this._sortedNodeNames.find((projectName) => {
-      const p = this.nodes[projectName];
+    if (isRelativePath(normalizedImportExpr)) {
+      const resolvedModule = join(dirname(filePath), normalizedImportExpr);
+      return this.findProjectOfResolvedModule(resolvedModule);
+    }
 
-      if (!isWorkspaceProject(p)) {
-        return false;
+    if (this.paths && this.paths[normalizedImportExpr]) {
+      for (let p of this.paths[normalizedImportExpr]) {
+        const maybeResolvedProject = this.findProjectOfResolvedModule(p);
+        if (maybeResolvedProject) {
+          return maybeResolvedProject;
+        }
       }
+    }
 
-      if (resolvedModule && resolvedModule.startsWith(p.data.root)) {
-        return true;
-      } else {
-        const normalizedRoot = normalizedProjectRoot(p);
-        const projectImport = `@${npmScope}/${normalizedRoot}`;
-        return normalizedImportExpr.startsWith(projectImport);
-      }
+    const resolvedModule = this.cache.has(normalizedImportExpr)
+      ? this.cache.get(normalizedImportExpr)
+      : resolveModuleByImport(normalizedImportExpr, filePath);
+
+    this.cache.set(normalizedImportExpr, resolvedModule);
+    if (resolvedModule) {
+      return this.findProjectOfResolvedModule(resolvedModule);
+    }
+
+    const importedProject = this.sortedWorkspaceProjects.find((p) => {
+      const projectImport = `@${npmScope}/${p.data.normalizedRoot}`;
+      return normalizedImportExpr.startsWith(projectImport);
     });
+
+    return importedProject?.name;
+  }
+
+  private findProjectOfResolvedModule(resolvedModule: string) {
+    const importedProject = this.sortedWorkspaceProjects.find((p) => {
+      return resolvedModule.startsWith(p.data.root);
+    });
+
+    return importedProject?.name;
   }
 }

Diff for: packages/workspace/src/utils/ast-utils.ts

@@ -402,7 +402,13 @@ export function getFullProjectGraphFromHost(host: Tree): ProjectGraph {
   const workspaceJson = readJsonInTree(host, getWorkspacePath(host));
   const nxJson = readJsonInTree<NxJson>(host, '/nx.json');
 
-  const fileRead = (f: string) => host.read(f).toString();
+  const fileRead = (f: string) => {
+    try {
+      return host.read(f).toString();
+    } catch (e) {
+      throw new Error(`${f} does not exist`);
+    }
+  };
 
   const workspaceFiles: FileData[] = [];
 

Diff for: packages/workspace/src/utils/fileutils.ts

@@ -35,7 +35,11 @@ export function serializeJson(json: any): string {
  * @param path Path of the JSON file on the filesystem
  */
 export function readJsonFile<T = any>(path: string): T {
-  return JSON.parse(stripJsonComments(fs.readFileSync(path, 'utf-8')));
+  return parseJsonWithComments<T>(fs.readFileSync(path, 'utf-8'));
+}
+
+export function parseJsonWithComments<T = any>(content: string): T {
+  return JSON.parse(stripJsonComments(content));
 }
 
 export function writeJsonFile(path: string, json: any) {