dpdm 4.0.1 → 4.2.0

package/src/parser.spec.ts

@@ -0,0 +1,134 @@
+/*!
+ * Copyright 2019 acrazing <joking.young@gmail.com>. All rights reserved.
+ * @since 2026-05-09 14:35:00
+ */
+
+import path from 'path';
+import { DependencyKind } from './consts';
+import { parseDependencyTree } from './parser';
+import {
+  groupDependencyTreeByPackage,
+  groupEntriesByPackage,
+  parseCircular,
+} from './utils';
+
+describe('parser', () => {
+  const fixture = path.join(__dirname, '../fixtures/parser/monorepo');
+
+  it('should parse relative entries from a custom cwd', async () => {
+    const tree = await parseDependencyTree('packages/shared/src/index.ts', {
+      cwd: fixture,
+    });
+
+    expect(tree).toEqual({
+      'packages/shared/src/index.ts': [
+        {
+          issuer: 'packages/shared/src/index.ts',
+          request: './dep',
+          kind: DependencyKind.StaticExport,
+          id: 'packages/shared/src/dep.ts',
+        },
+      ],
+      'packages/shared/src/dep.ts': [],
+    });
+  });
+
+  it('should parse an absolute entry file path', async () => {
+    const tree = await parseDependencyTree(
+      path.join(fixture, 'packages/shared/src/index.ts'),
+      {
+        context: fixture,
+      },
+    );
+
+    expect(tree).toEqual({
+      'packages/shared/src/index.ts': [
+        {
+          issuer: 'packages/shared/src/index.ts',
+          request: './dep',
+          kind: DependencyKind.StaticExport,
+          id: 'packages/shared/src/dep.ts',
+        },
+      ],
+      'packages/shared/src/dep.ts': [],
+    });
+  });
+
+  it('should resolve aliases from an absolute tsconfig path', async () => {
+    const tree = await parseDependencyTree(
+      path.join(fixture, 'packages/alias-user/src/index.ts'),
+      {
+        context: fixture,
+        tsconfig: path.join(fixture, 'tsconfig.json'),
+      },
+    );
+
+    expect(tree['packages/alias-user/src/index.ts']).toEqual([
+      {
+        issuer: 'packages/alias-user/src/index.ts',
+        request: '~/dep',
+        kind: DependencyKind.StaticImport,
+        id: 'packages/shared/src/dep.ts',
+      },
+    ]);
+  });
+
+  it('should group dependencies and circulars by package', async () => {
+    const tree = await parseDependencyTree(
+      ['packages/app/src/index.ts', 'packages/ui/src/index.ts'],
+      { cwd: fixture },
+    );
+    const packageTree = groupDependencyTreeByPackage(tree, fixture);
+
+    expect(
+      groupEntriesByPackage(
+        [
+          'packages/app/src/index.ts',
+          'packages/ui/src/index.ts',
+          'packages/app/src/local.ts',
+        ],
+        fixture,
+      ),
+    ).toEqual(['@repo/app', '@repo/ui']);
+    expect(packageTree).toEqual({
+      '@repo/app': [
+        {
+          issuer: '@repo/app',
+          request: '../../shared/src',
+          kind: DependencyKind.StaticImport,
+          id: '@repo/shared',
+        },
+        {
+          issuer: '@repo/app',
+          request: '../../ui/src',
+          kind: DependencyKind.StaticImport,
+          id: '@repo/ui',
+        },
+      ],
+      '@repo/ui': [
+        {
+          issuer: '@repo/ui',
+          request: '../../shared/src',
+          kind: DependencyKind.StaticImport,
+          id: '@repo/shared',
+        },
+      ],
+      '@repo/shared': [],
+    });
+    expect(parseCircular(packageTree)).toEqual([]);
+  });
+
+  it('should detect package-level circular dependencies', async () => {
+    const tree = await parseDependencyTree(
+      ['packages/cycle-a/src/index.ts', 'packages/cycle-b/src/index.ts'],
+      {
+        cwd: fixture,
+      },
+    );
+    const packageTree = groupDependencyTreeByPackage(tree, fixture);
+
+    const circulars = parseCircular(packageTree);
+    expect(circulars).toHaveLength(1);
+    expect(circulars[0].sort()).toEqual(['@repo/cycle-a', '@repo/cycle-b']);
+  });
+});

package/src/parser.ts

@@ -134,15 +134,14 @@ export async function parseDependencyTree(
   if (!Array.isArray(entries)) {
     entries = [entries];
   }
-  const currentDirectory = process.cwd();
   const output: DependencyTree = {};
   const fullOptions = normalizeOptions(options);
   let resolve = simpleResolver;
-  if (options.tsconfig) {
+  if (fullOptions.tsconfig) {
     const compilerOptions = ts.parseJsonConfigFileContent(
-      ts.readConfigFile(options.tsconfig, ts.sys.readFile).config,
+      ts.readConfigFile(fullOptions.tsconfig, ts.sys.readFile).config,
       ts.sys,
-      path.dirname(options.tsconfig),
+      path.dirname(fullOptions.tsconfig),
     ).options;
 
     const host = ts.createCompilerHost(compilerOptions);
@@ -170,12 +169,12 @@ export async function parseDependencyTree(
   }
   await Promise.all(
     entries.map((entry) =>
-      G.glob(entry).then((matches) =>
+      G.glob(entry, { cwd: fullOptions.cwd }).then((matches) =>
         Promise.all(
           matches.map((filename) =>
             parseTreeRecursive(
-              currentDirectory,
-              path.join(currentDirectory, filename),
+              fullOptions.cwd,
+              path.resolve(fullOptions.cwd, filename),
               fullOptions,
               output,
               resolve,

package/src/types.ts

@@ -6,6 +6,7 @@
 import { DependencyKind } from './consts';
 
 export interface ParseOptions {
+  cwd: string;
   context: string;
   extensions: string[];
   js: string[];

package/src/utils.spec.ts

@@ -61,11 +61,15 @@ describe('util', () => {
   });
 
   describe('When parsing circular', () => {
-    function dependencyFactory(id: string): Dependency {
+    function dependencyFactory(
+      id: string,
+      issuer: string = '',
+      kind = DependencyKind.StaticImport,
+    ): Dependency {
       return {
-        issuer: '',
+        issuer,
         request: '',
-        kind: DependencyKind.StaticImport,
+        kind,
         id,
       };
     }
@@ -225,5 +229,62 @@ describe('util', () => {
         expect(actual[1]).toMatchObject(['start', 'mid', 'right']);
       });
     });
+
+    describe('When skip imports are specified', () => {
+      it('Should not skip imports when the skip list is empty', () => {
+        const tree = {
+          a: [dependencyFactory('b', 'a')],
+          b: [dependencyFactory('a', 'b')],
+        };
+
+        expect(parseCircular(tree, false, [])).toEqual([['a', 'b']]);
+      });
+
+      it('Should ignore a matching import edge when parsing circulars', () => {
+        const tree = {
+          a: [dependencyFactory('b', 'a')],
+          b: [dependencyFactory('a', 'b')],
+        };
+
+        expect(parseCircular(tree, false, [['b', 'a']])).toEqual([]);
+      });
+
+      it('Should only ignore the specified import edge', () => {
+        const tree = {
+          start: [
+            dependencyFactory('left', 'start'),
+            dependencyFactory('right', 'start'),
+          ],
+          left: [dependencyFactory('start', 'left')],
+          right: [dependencyFactory('start', 'right')],
+        };
+
+        const actual = parseCircular(tree, false, [['left', 'start']]);
+        expect(actual).toHaveLength(1);
+        expect(actual[0]).toMatchObject(['start', 'right']);
+      });
+
+      it('Should support regexp patterns for skipped imports', () => {
+        const tree = {
+          'src/a.js': [
+            dependencyFactory('src/b.js', 'src/a.js'),
+            dependencyFactory('src/c.js', 'src/a.js'),
+          ],
+          'src/b.js': [dependencyFactory('src/a.js', 'src/b.js')],
+          'src/c.js': [dependencyFactory('src/a.js', 'src/c.js')],
+        };
+
+        expect(parseCircular(tree, false, [['src/a.js', '.*']])).toEqual([]);
+      });
+
+      it('Should not match skipped imports by prefix', () => {
+        const tree = {
+          a: [dependencyFactory('bc', 'a')],
+          bc: [dependencyFactory('a', 'bc')],
+        };
+
+        expect(parseCircular(tree, false, [['a', 'b']])).toEqual([['a', 'bc']]);
+      });
+    });
   });
 });

package/src/utils.ts

@@ -12,7 +12,21 @@ import { Dependency, DependencyTree, ParseOptions } from './types';
 
 const allBuiltins = new Set(builtinModules);
 
+export type SkippedImport = readonly [string, string];
+
+function createSkippedImportsRegExp(
+  skipImports: readonly SkippedImport[],
+): RegExp {
+  if (skipImports.length === 0) {
+    return /$./;
+  }
+  return new RegExp(
+    `^(?:${skipImports.map((item) => item.join(':')).join('|')})$`,
+  );
+}
+
 export const defaultOptions: ParseOptions = {
+  cwd: process.cwd(),
   context: process.cwd(),
   extensions: ['', '.ts', '.tsx', '.mjs', '.js', '.jsx', '.json'],
   js: ['.ts', '.tsx', '.mjs', '.js', '.jsx'],
@@ -26,27 +40,29 @@ export const defaultOptions: ParseOptions = {
 
 export function normalizeOptions(options: Partial<ParseOptions>): ParseOptions {
   const newOptions = { ...defaultOptions, ...options };
+  newOptions.cwd = path.resolve(options.cwd || process.cwd());
+  newOptions.context = path.resolve(newOptions.cwd, options.context || '.');
   if (newOptions.extensions.indexOf('') < 0) {
     newOptions.extensions.unshift('');
   }
-  newOptions.context = path.resolve(newOptions.context);
   if (options.tsconfig === void 0) {
     try {
       const tsconfig = path.join(newOptions.context, 'tsconfig.json');
       const stat = fs.statSync(tsconfig);
       if (stat.isFile()) {
-        options.tsconfig = tsconfig;
+        newOptions.tsconfig = tsconfig;
       }
     } catch {}
   } else {
+    const tsconfig = path.resolve(newOptions.cwd, options.tsconfig);
     let stat: fs.Stats | undefined;
     try {
-      stat = fs.statSync(options.tsconfig);
+      stat = fs.statSync(tsconfig);
     } catch {}
     if (!stat || !stat.isFile()) {
       throw new Error(`specified tsconfig "${options.tsconfig}" is not a file`);
     }
-    options.tsconfig = path.join(process.cwd(), options.tsconfig);
+    newOptions.tsconfig = tsconfig;
   }
   return newOptions;
 }
@@ -127,11 +143,135 @@ export function shortenTree(
   return output;
 }
 
+function getPackageNameFromRequest(request: string): string | null {
+  if (request.startsWith('.') || path.isAbsolute(request)) {
+    return null;
+  }
+  const parts = request.split('/');
+  if (request.startsWith('@')) {
+    return parts.length > 1 ? parts.slice(0, 2).join('/') : request;
+  }
+  return parts[0] || null;
+}
+
+function getPackageNameFromPath(
+  context: string,
+  id: string,
+  cache: Map<string, string | null>,
+): string | null {
+  if (allBuiltins.has(id)) {
+    return id;
+  }
+  const fullPath = path.isAbsolute(id) ? id : path.resolve(context, id);
+  let current = path.extname(fullPath) ? path.dirname(fullPath) : fullPath;
+  const root = path.parse(current).root;
+
+  while (true) {
+    const cached = cache.get(current);
+    if (cached !== void 0) {
+      return cached;
+    }
+
+    try {
+      const pkg = fs.readJSONSync(path.join(current, 'package.json'));
+      const name =
+        typeof pkg.name === 'string' && pkg.name
+          ? pkg.name
+          : path.relative(context, current) || path.basename(current);
+      cache.set(current, name);
+      return name;
+    } catch {}
+
+    if (current === root) {
+      cache.set(current, null);
+      return null;
+    }
+    current = path.dirname(current);
+  }
+}
+
+export function getPackageName(context: string, id: string): string | null {
+  return getPackageNameFromPath(context, id, new Map());
+}
+
+export function groupDependencyTreeByPackage(
+  tree: DependencyTree,
+  context: string,
+): DependencyTree {
+  const packages: Record<string, Dependency[] | null> = {};
+  const edges: Record<string, Set<string>> = {};
+  const cache = new Map<string, string | null>();
+
+  function ensurePackage(id: string, ignored = false) {
+    if (!(id in packages)) {
+      packages[id] = ignored ? null : [];
+    } else if (packages[id] === null && !ignored) {
+      packages[id] = [];
+    }
+  }
+
+  for (const id in tree) {
+    const issuerPackage = getPackageNameFromPath(context, id, cache) || id;
+    const deps = tree[id];
+    ensurePackage(issuerPackage, deps === null);
+    if (!deps) {
+      continue;
+    }
+
+    for (const dep of deps) {
+      const dependencyPackage = dep.id
+        ? getPackageNameFromPath(context, dep.id, cache)
+        : getPackageNameFromRequest(dep.request);
+      if (!dependencyPackage || dependencyPackage === issuerPackage) {
+        continue;
+      }
+
+      ensurePackage(dependencyPackage, dep.id ? tree[dep.id] === null : false);
+      const edgeSet = (edges[issuerPackage] =
+        edges[issuerPackage] || new Set());
+      if (edgeSet.has(dependencyPackage)) {
+        continue;
+      }
+      edgeSet.add(dependencyPackage);
+      (packages[issuerPackage] as Dependency[]).push({
+        issuer: issuerPackage,
+        request: dep.request,
+        kind: dep.kind,
+        id: dependencyPackage,
+      });
+    }
+  }
+
+  for (const id in packages) {
+    packages[id]?.sort((a, b) => a.id!.localeCompare(b.id!));
+  }
+  return packages;
+}
+
+export function groupEntriesByPackage(
+  entries: string[],
+  context: string,
+): string[] {
+  const output: string[] = [];
+  const seen = new Set<string>();
+  const cache = new Map<string, string | null>();
+  for (const entry of entries) {
+    const id = getPackageNameFromPath(context, entry, cache) || entry;
+    if (!seen.has(id)) {
+      output.push(id);
+      seen.add(id);
+    }
+  }
+  return output;
+}
+
 export function parseCircular(
   tree: DependencyTree,
   skipDynamicImports: boolean = false,
+  skipImports: readonly SkippedImport[] = [],
 ): string[][] {
   const circulars: string[][] = [];
+  const skippedImports = createSkippedImportsRegExp(skipImports);
 
   tree = { ...tree };
 
@@ -147,7 +287,9 @@ export function parseCircular(
         deps.forEach((dep) => {
           if (
             dep.id &&
-            (!skipDynamicImports || dep.kind !== DependencyKind.DynamicImport)
+            (!skipDynamicImports ||
+              dep.kind !== DependencyKind.DynamicImport) &&
+            !skippedImports.test(`${dep.issuer}:${dep.id}`)
           ) {
             visit(dep.id, used.slice());
           }