dpdm 4.1.0 → 4.2.0

package/src/bin/dpdm.ts

@@ -14,6 +14,8 @@ import { parseDependencyTree } from '../parser';
 import { ParseOptions } from '../types';
 import {
   defaultOptions,
+  groupDependencyTreeByPackage,
+  groupEntriesByPackage,
   isEmpty,
   parseCircular,
   parseWarnings,
@@ -34,6 +36,10 @@ function normalizeCircularId(context: string, id: string) {
   return path.relative(context, fullPath);
 }
 
+function resolveFromCwd(cwd: string, target: string): string {
+  return path.resolve(cwd, target);
+}
+
 function parseSkipImports(
   skipImports: string[],
   context: string,
@@ -70,7 +76,11 @@ async function main() {
     )
     .option('context', {
       type: 'string',
-      desc: 'the context directory to shorten path, default is current directory',
+      desc: 'the context directory to shorten path, default is cwd',
+    })
+    .option('cwd', {
+      type: 'string',
+      desc: 'the working directory used to match files and resolve relative paths, default is current directory',
     })
     .option('extensions', {
       alias: 'ext',
@@ -149,6 +159,11 @@ async function main() {
       array: true,
       desc: 'Skip import edges from circular checks. Values are regexp ISSUER:DEPENDENCY pairs.',
     })
+    .option('group-by-package', {
+      type: 'boolean',
+      desc: 'print dependencies and circulars grouped by nearest package.json',
+      default: false,
+    })
     .alias('h', 'help')
     .wrap(Math.min(y.terminalWidth(), 100))
     .parseAsync();
@@ -182,7 +197,8 @@ async function main() {
   let ended = 0;
   let current = '';
 
-  const context = argv.context || process.cwd();
+  const cwd = path.resolve((argv.cwd as string | undefined) || process.cwd());
+  const context = path.resolve(cwd, argv.context || '.');
   const skippedImports = parseSkipImports(
     ((argv.skipImports as string[] | undefined) || []).flatMap(
       splitSkipImportValue,
@@ -207,6 +223,7 @@ async function main() {
   }
 
   const options: ParseOptions = {
+    cwd,
     context,
     extensions: argv.extensions.split(','),
     js: argv.js.split(','),
@@ -224,39 +241,54 @@ async function main() {
         throw new Error(`No entry files were matched.`);
       }
       o.succeed(`[${ended}/${total}] Analyze done!`);
-      const entriesDeep = await Promise.all(files.map((g) => G.glob(g)));
+      const entriesDeep = await Promise.all(
+        files.map((g) => G.glob(g, { cwd })),
+      );
       const entries = await Promise.all(
         Array<string>()
           .concat(...entriesDeep)
-          .map((name) =>
-            simpleResolver(
-              options.context!,
-              path.join(options.context!, name),
-              options.extensions,
-            ).then((id) => (id ? path.relative(options.context!, id) : name)),
-          ),
+          .map((name) => {
+            const fullName = resolveFromCwd(cwd, name);
+            return simpleResolver(cwd, fullName, options.extensions).then(
+              (id) => path.relative(context, id || fullName),
+            );
+          }),
       );
+      const displayedTree = argv.groupByPackage
+        ? groupDependencyTreeByPackage(tree, context)
+        : tree;
+      const displayedEntries = argv.groupByPackage
+        ? groupEntriesByPackage(entries, context)
+        : entries;
       const circulars = parseCircular(
-        tree,
+        displayedTree,
         argv.skipDynamicImports === 'circular',
         skippedImports,
       );
       if (argv.output) {
         await fs.outputJSON(
           argv.output,
-          { entries, tree, circulars },
+          { entries: displayedEntries, tree: displayedTree, circulars },
           { spaces: 2 },
         );
       }
       if (argv.tree) {
-        console.log(chalk.bold('• Dependencies Tree'));
-        console.log(prettyTree(tree, entries));
+        console.log(
+          chalk.bold(
+            argv.groupByPackage
+              ? '• Package Dependencies Tree'
+              : '• Dependencies Tree',
+          ),
+        );
+        console.log(prettyTree(displayedTree, displayedEntries));
         console.log('');
       }
       if (argv.circular) {
         console.log(
           chalk.bold[circulars.length === 0 ? 'green' : 'red'](
-            '• Circular Dependencies',
+            argv.groupByPackage
+              ? '• Package Circular Dependencies'
+              : '• Circular Dependencies',
           ),
         );
         if (circulars.length === 0) {
@@ -276,8 +308,10 @@ async function main() {
         console.log('');
       }
       if (argv.detectUnusedFilesFrom) {
-        const allFiles = await G.glob(argv.detectUnusedFilesFrom);
-        const shortAllFiles = allFiles.map((v) => path.relative(context, v));
+        const allFiles = await G.glob(argv.detectUnusedFilesFrom, { cwd });
+        const shortAllFiles = allFiles.map((v) =>
+          path.relative(context, resolveFromCwd(cwd, v)),
+        );
         const unusedFiles = shortAllFiles.filter((v) => !(v in tree)).sort();
         console.log(chalk.bold.cyan('• Unused files'));
         if (unusedFiles.length === 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.ts

@@ -26,6 +26,7 @@ function createSkippedImportsRegExp(
 }
 
 export const defaultOptions: ParseOptions = {
+  cwd: process.cwd(),
   context: process.cwd(),
   extensions: ['', '.ts', '.tsx', '.mjs', '.js', '.jsx', '.json'],
   js: ['.ts', '.tsx', '.mjs', '.js', '.jsx'],
@@ -39,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;
 }
@@ -140,6 +143,128 @@ 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,