@pnpm/deps.inspection.tree-builder 1101.0.7 → 1101.0.9

package/CHANGELOG.md

@@ -1,5 +1,24 @@
 # @pnpm/reviewing.dependencies-hierarchy
 
+## 1101.0.9
+
+### Patch Changes
+
+- Updated dependencies:
+  - @pnpm/config.matcher@1100.0.3
+  - @pnpm/lockfile.fs@1100.2.12
+  - @pnpm/store.cafs@1100.3.6
+
+## 1101.0.8
+
+### Patch Changes
+
+- `pnpm list` now shows an unsaved dependency named `constructor`, and `pnpm why` no longer labels a dependency aliased `constructor` as a dev dependency.
+
+- Updated dependencies:
+  - @pnpm/lockfile.fs@1100.2.11
+  - @pnpm/store.index@1101.0.0
+
 ## 1101.0.7
 
 ### Patch Changes

package/lib/buildDependenciesTree.js

@@ -33,102 +33,121 @@ async function buildProjectsTrees(projectPaths, maybeOpts, linkedWalk) {
     const modulesDir = await realpathMissing(pathAbsolute(maybeOpts.modulesDir ?? 'node_modules', maybeOpts.lockfileDir));
     const modules = await readModulesManifest(modulesDir);
     const registriesByScope = normalizeRegistriesByScope(maybeOpts?.registriesByScope);
-    const internalPnpmDir = path.join(modulesDir, '.pnpm');
-    const currentLockfile = await readCurrentLockfile(internalPnpmDir, { ignoreIncompatible: false });
-    const wantedLockfile = await readWantedLockfile(maybeOpts.lockfileDir, { ignoreIncompatible: false });
-    if (projectPaths == null) {
-        projectPaths = Object.keys(wantedLockfile?.importers ?? {})
-            .map((id) => path.join(maybeOpts.lockfileDir, id));
-    }
-    const result = {};
+    const { currentLockfile, wantedLockfile } = await readLockfiles(modulesDir, maybeOpts.lockfileDir);
+    const projectDirs = projectPaths ?? getImporterDirs(wantedLockfile, maybeOpts.lockfileDir);
     const lockfileToUse = maybeOpts.checkWantedLockfileOnly ? wantedLockfile : (currentLockfile ?? wantedLockfile);
     if (!lockfileToUse) {
-        for (const projectPath of projectPaths) {
-            result[projectPath] = {};
-        }
-        return result;
+        return Object.fromEntries(projectDirs.map((projectPath) => [projectPath, {}]));
     }
-    const storeDir = modules?.storeDir;
-    const storeIndex = storeDir ? new StoreIndex(storeDir) : undefined;
-    const opts = {
-        depth: maybeOpts.depth || 0,
-        excludePeerDependencies: maybeOpts.excludePeerDependencies,
-        include: maybeOpts.include ?? {
-            dependencies: true,
-            devDependencies: true,
-            optionalDependencies: true,
-        },
-        lockfileDir: maybeOpts.lockfileDir,
-        checkWantedLockfileOnly: maybeOpts.checkWantedLockfileOnly,
-        onlyProjects: maybeOpts.onlyProjects,
+    const storeIndex = modules?.storeDir ? new StoreIndex(modules.storeDir) : undefined;
+    const ctx = createHierarchyContext({
+        lockfile: lockfileToUse,
+        wantedLockfile,
+        projectDirs,
+        treeOpts: maybeOpts,
+        modules,
+        modulesDir,
         registriesByScope,
-        registriesByPrefix: maybeOpts.registriesByPrefix,
-        search: maybeOpts.search,
-        showDedupedSearchMatches: maybeOpts.showDedupedSearchMatches ?? (maybeOpts.search != null),
-        skipped: new Set(modules?.skipped ?? []),
-        storeDir,
         storeIndex,
-        modulesDir,
-        virtualStoreDir: modules?.virtualStoreDir,
-        virtualStoreDirMaxLength: modules?.virtualStoreDirMaxLength ?? maybeOpts.virtualStoreDirMaxLength,
-    };
+    });
+    const pairs = await Promise.all(projectDirs.map(async (projectPath) => {
+        return [
+            projectPath,
+            await dependenciesHierarchyForPackage(ctx, projectPath),
+        ];
+    }));
+    storeIndex?.close();
+    if (ctx.onlyProjects) {
+        await expandLinkedProjectsOfEach(pairs, {
+            importers: lockfileToUse.importers,
+            lockfileDir: ctx.lockfileDir,
+            depth: ctx.depth,
+            treeOpts: maybeOpts,
+            linkedWalk,
+        });
+    }
+    return Object.fromEntries(pairs);
+}
+async function readLockfiles(modulesDir, lockfileDir) {
+    const installStateDir = path.join(modulesDir, '.pnpm');
+    const currentLockfile = await readCurrentLockfile(installStateDir, { ignoreIncompatible: false });
+    const wantedLockfile = await readWantedLockfile(lockfileDir, { ignoreIncompatible: false });
+    return { currentLockfile, wantedLockfile };
+}
+function getImporterDirs(wantedLockfile, lockfileDir) {
+    return Object.keys(wantedLockfile?.importers ?? {})
+        .map((id) => path.join(lockfileDir, id));
+}
+function createHierarchyContext(sources) {
+    const { lockfile, treeOpts } = sources;
+    const opts = createTreeOptions(sources);
     // Build the dependency graph ONCE for all importers and share a single
     // MaterializationCache so that identical subtrees are only materialized once.
     const allRootIds = [];
-    for (const projectPath of projectPaths) {
+    for (const projectPath of sources.projectDirs) {
         const importerId = getLockfileImporterId(opts.lockfileDir, projectPath);
-        if (lockfileToUse.importers[importerId]) {
+        if (lockfile.importers[importerId]) {
             allRootIds.push({ type: 'importer', importerId });
         }
     }
     const sharedGraph = buildDependencyGraph(allRootIds, {
-        currentPackages: lockfileToUse.packages ?? {},
-        importers: lockfileToUse.importers,
+        currentPackages: lockfile.packages ?? {},
+        importers: lockfile.importers,
         include: opts.include,
         lockfileDir: opts.lockfileDir,
         onlyProjects: opts.onlyProjects,
-        peerSatisfactionEdges: getPeerSatisfactionEdgesToSkip(lockfileToUse, {
+        peerSatisfactionEdges: getPeerSatisfactionEdgesToSkip(lockfile, {
             include: opts.include,
-            resolvePeersFromWorkspaceRoot: maybeOpts.resolvePeersFromWorkspaceRoot,
+            resolvePeersFromWorkspaceRoot: treeOpts.resolvePeersFromWorkspaceRoot,
         }),
     });
     const sharedMaterializationCache = new Map();
-    const sharedDepTypes = detectDepTypes(lockfileToUse, maybeOpts);
-    const ctx = {
-        currentLockfile: lockfileToUse,
-        wantedLockfile,
+    const sharedDepTypes = detectDepTypes(lockfile, treeOpts);
+    return {
+        currentLockfile: lockfile,
+        wantedLockfile: sources.wantedLockfile,
         ...opts,
         graph: sharedGraph,
         materializationCache: sharedMaterializationCache,
         depTypes: sharedDepTypes,
     };
-    const getHierarchy = dependenciesHierarchyForPackage.bind(null, ctx);
-    const pairs = await Promise.all(projectPaths.map(async (projectPath) => {
-        return [
-            projectPath,
-            await getHierarchy(projectPath),
-        ];
-    }));
-    storeIndex?.close();
+}
+function createTreeOptions({ treeOpts, modules, modulesDir, registriesByScope, storeIndex }) {
+    return {
+        depth: treeOpts.depth || 0,
+        excludePeerDependencies: treeOpts.excludePeerDependencies,
+        include: treeOpts.include ?? {
+            dependencies: true,
+            devDependencies: true,
+            optionalDependencies: true,
+        },
+        lockfileDir: treeOpts.lockfileDir,
+        checkWantedLockfileOnly: treeOpts.checkWantedLockfileOnly,
+        onlyProjects: treeOpts.onlyProjects,
+        registriesByScope,
+        registriesByPrefix: treeOpts.registriesByPrefix,
+        search: treeOpts.search,
+        showDedupedSearchMatches: treeOpts.showDedupedSearchMatches ?? (treeOpts.search != null),
+        skipped: new Set(modules?.skipped ?? []),
+        storeDir: modules?.storeDir,
+        storeIndex,
+        modulesDir,
+        virtualStoreDir: modules?.virtualStoreDir,
+        virtualStoreDirMaxLength: modules?.virtualStoreDirMaxLength ?? treeOpts.virtualStoreDirMaxLength,
+    };
+}
+async function expandLinkedProjectsOfEach(pairs, opts) {
+    const { linkedWalk, ...ctx } = opts;
+    // Sequential, so that the first occurrence of a linked project is the
+    // one expanded, as with the deduplication of a shared lockfile.
     for (const [projectPath, dependenciesHierarchy] of pairs) {
-        result[projectPath] = dependenciesHierarchy;
-    }
-    if (opts.onlyProjects) {
-        // Sequential, so that the first occurrence of a linked project is the
-        // one expanded, as with the deduplication of a shared lockfile.
-        for (const [projectPath, dependenciesHierarchy] of pairs) {
-            // eslint-disable-next-line no-await-in-loop
-            await expandLinkedProjects(dependenciesHierarchy, {
-                importers: lockfileToUse.importers,
-                lockfileDir: opts.lockfileDir,
-                depth: opts.depth,
-                treeOpts: maybeOpts,
-                walk: { ...linkedWalk, ancestors: new Set([...linkedWalk.ancestors, projectPath]) },
-                rewriteLinkVersionDir: projectPath,
-            });
-        }
+        // eslint-disable-next-line no-await-in-loop -- the first occurrence of a linked project must be the one expanded, so projects are expanded in order
+        await expandLinkedProjects(dependenciesHierarchy, {
+            ...ctx,
+            walk: { ...linkedWalk, ancestors: new Set([...linkedWalk.ancestors, projectPath]) },
+            rewriteLinkVersionDir: projectPath,
+        });
     }
-    return result;
 }
 /**
  * Attaches the project dependencies of every linked workspace project that
@@ -139,7 +158,7 @@ async function buildProjectsTrees(projectPaths, maybeOpts, linkedWalk) {
 async function expandLinkedProjects(tree, ctx) {
     for (const field of DEPENDENCIES_FIELDS) {
         if (tree[field] != null) {
-            // eslint-disable-next-line no-await-in-loop
+            // eslint-disable-next-line no-await-in-loop -- the walk is sequential so the first occurrence of a linked project is the one expanded
             tree[field] = await expandLinkedProjectNodes(tree[field], 0, ctx);
         }
     }
@@ -149,11 +168,11 @@ async function expandLinkedProjectNodes(nodes, level, ctx) {
     for (const node of nodes) {
         let expandedNode = node;
         if (node.dependencies != null) {
-            // eslint-disable-next-line no-await-in-loop
+            // eslint-disable-next-line no-await-in-loop -- the walk is sequential so the first occurrence of a linked project is the one expanded
             expandedNode = keepSearched({ ...node, dependencies: await expandLinkedProjectNodes(node.dependencies, level + 1, ctx) }, ctx);
         }
         else if (!node.circular && ctx.importers[getLockfileImporterId(ctx.lockfileDir, node.path)] == null) {
-            // eslint-disable-next-line no-await-in-loop
+            // eslint-disable-next-line no-await-in-loop -- the walk is sequential so the first occurrence of a linked project is the one expanded
             expandedNode = await expandLinkedProject(node, level, ctx);
         }
         if (expandedNode != null)
@@ -212,38 +231,24 @@ function rewriteLinkVersions(nodes, linkedProjectDir, rewriteLinkVersionDir) {
 async function dependenciesHierarchyForPackage(opts, projectPath) {
     const { currentLockfile, wantedLockfile } = opts;
     const importerId = getLockfileImporterId(opts.lockfileDir, projectPath);
-    if (!currentLockfile.importers[importerId])
+    const projectSnapshot = currentLockfile.importers[importerId];
+    if (!projectSnapshot)
         return {};
     const modulesDir = opts.modulesDir && path.isAbsolute(opts.modulesDir)
         ? opts.modulesDir
         : path.join(projectPath, opts.modulesDir ?? 'node_modules');
-    const currentPackages = currentLockfile.packages ?? {};
-    const wantedPackages = wantedLockfile?.packages ?? {};
-    // Build a map from alias → dependency field for post-categorization.
-    const result = {};
-    const fieldMap = new Map();
-    for (const field of DEPENDENCIES_FIELDS.sort().filter(f => opts.include[f])) {
-        result[field] = [];
-        const fieldDeps = currentLockfile.importers[importerId][field] ?? {};
-        for (const alias in fieldDeps) {
-            fieldMap.set(alias, field);
-        }
-    }
-    const parentId = { type: 'importer', importerId };
-    // Materialize the tree rooted at this importer in a single getTree call.
-    // materializeChildren handles all dedup, search, and circular detection.
+    const { result, fieldMap } = initDependencyFields(projectSnapshot, opts.include);
     // The depth is incremented by 1 because the importer itself is one level;
     // opts.depth controls how deep *below* the direct dependencies we go.
     const nodes = getTree({
         ...opts,
-        currentPackages,
+        currentPackages: currentLockfile.packages ?? {},
         importers: currentLockfile.importers,
         rewriteLinkVersionDir: projectPath,
         maxDepth: opts.depth + 1,
-        wantedPackages,
+        wantedPackages: wantedLockfile?.packages ?? {},
         modulesDir,
-    }, parentId);
-    // Categorize the materialized nodes into their dependency fields.
+    }, { type: 'importer', importerId });
     for (const node of nodes) {
         const field = fieldMap.get(node.alias);
         if (field != null) {
@@ -255,36 +260,54 @@ async function dependenciesHierarchyForPackage(opts, projectPath) {
     // graph and can't have dependency subtrees showing paths to the search target.
     // They aren't workspace projects either, which is all onlyProjects lists.
     if (!opts.search && !opts.onlyProjects) {
-        const savedDeps = getAllDirectDependencies(currentLockfile.importers[importerId]);
-        const unsavedDeps = ((await readModulesDir(modulesDir)) ?? []).filter((directDep) => !savedDeps[directDep]);
-        if (unsavedDeps.length > 0)
-            await Promise.all(unsavedDeps.map((unsavedDep) => limitUnsavedReads(async () => {
-                let pkgPath = path.join(modulesDir, unsavedDep);
-                let version;
-                try {
-                    pkgPath = await resolveLinkTarget(pkgPath);
-                    version = `link:${normalizePath(path.relative(projectPath, pkgPath))}`;
-                }
-                catch {
-                    // if error happened. The package is not a link
-                    const pkg = await safeReadPackageJsonFromDir(pkgPath);
-                    version = pkg?.version ?? 'undefined';
-                }
-                const pkg = {
-                    alias: unsavedDep,
-                    isMissing: false,
-                    isPeer: false,
-                    isSkipped: false,
-                    name: unsavedDep,
-                    path: pkgPath,
-                    version,
-                };
-                result.unsavedDependencies = result.unsavedDependencies ?? [];
-                result.unsavedDependencies.push(pkg);
-            })));
+        await addUnsavedDependencies(result, { modulesDir, projectPath, projectSnapshot });
     }
     return result;
 }
+function initDependencyFields(projectSnapshot, include) {
+    const result = {};
+    const fieldMap = new Map();
+    for (const field of DEPENDENCIES_FIELDS.sort().filter(f => include[f])) {
+        result[field] = [];
+        for (const alias in projectSnapshot[field] ?? {}) {
+            fieldMap.set(alias, field);
+        }
+    }
+    return { result, fieldMap };
+}
+async function addUnsavedDependencies(result, { modulesDir, projectPath, projectSnapshot }) {
+    const savedDeps = getAllDirectDependencies(projectSnapshot);
+    const unsavedDeps = ((await readModulesDir(modulesDir)) ?? []).filter((directDep) => !Object.hasOwn(savedDeps, directDep));
+    if (unsavedDeps.length === 0)
+        return;
+    await Promise.all(unsavedDeps.map((unsavedDep) => limitUnsavedReads(async () => {
+        const pkg = await readUnsavedDependency(unsavedDep, { modulesDir, projectPath });
+        result.unsavedDependencies = result.unsavedDependencies ?? [];
+        result.unsavedDependencies.push(pkg);
+    })));
+}
+async function readUnsavedDependency(unsavedDep, { modulesDir, projectPath }) {
+    let pkgPath = path.join(modulesDir, unsavedDep);
+    let version;
+    try {
+        pkgPath = await resolveLinkTarget(pkgPath);
+        version = `link:${normalizePath(path.relative(projectPath, pkgPath))}`;
+    }
+    catch {
+        // if error happened. The package is not a link
+        const pkg = await safeReadPackageJsonFromDir(pkgPath);
+        version = pkg?.version ?? 'undefined';
+    }
+    return {
+        alias: unsavedDep,
+        isMissing: false,
+        isPeer: false,
+        isSkipped: false,
+        name: unsavedDep,
+        path: pkgPath,
+        version,
+    };
+}
 function getAllDirectDependencies(projectSnapshot) {
     return {
         ...projectSnapshot.dependencies,

package/lib/buildDependencyGraph.d.ts

@@ -17,7 +17,7 @@ interface DependencyGraphNode {
 export interface DependencyGraph {
     nodes: Map<string, DependencyGraphNode>;
 }
-export declare function buildDependencyGraph(rootIds: TreeNodeId[], opts: {
+interface DependencyGraphOptions {
     currentPackages: PackageSnapshots;
     importers: Record<string, ProjectSnapshot>;
     include: {
@@ -29,7 +29,8 @@ export declare function buildDependencyGraph(rootIds: TreeNodeId[], opts: {
     onlyProjects?: boolean;
     /** Edges left out of the graph, from `getPeerSatisfactionEdgesToSkip`. */
     peerSatisfactionEdges?: PeerSatisfactionEdges;
-}): DependencyGraph;
+}
+export declare function buildDependencyGraph(rootIds: TreeNodeId[], opts: DependencyGraphOptions): DependencyGraph;
 /**
  * Whether an edge may lead to a project. Besides the importers of the lockfile,
  * this includes a project's `link:` dependency on a directory outside the

package/lib/buildDependencyGraph.js

@@ -12,63 +12,81 @@ export function buildDependencyGraph(rootIds, opts) {
         if (visited.has(serialized))
             continue;
         visited.add(serialized);
-        const snapshot = getSnapshot(nodeId, opts);
-        if (!snapshot) {
-            graph.nodes.set(serialized, { nodeId, edges: [], peers: new Set() });
-            continue;
-        }
-        // For importers, only include the dependency fields the caller selected.
-        // For packages, devDependencies don't exist in the lockfile.
-        const deps = nodeId.type === 'importer'
-            ? {
-                ...(opts.include.dependencies !== false ? snapshot.dependencies : undefined),
-                ...(opts.include.devDependencies !== false ? snapshot.devDependencies : undefined),
-                ...(opts.include.dependencies !== false && opts.include.optionalDependencies ? snapshot.optionalDependencies : undefined),
-            }
-            : !opts.include.optionalDependencies
-                ? snapshot.dependencies
-                : {
-                    ...snapshot.dependencies,
-                    ...snapshot.optionalDependencies,
-                };
-        const peers = new Set(Object.keys(nodeId.type === 'package'
-            ? (opts.currentPackages[nodeId.depPath]?.peerDependencies ?? {})
-            : {}));
-        const edges = [];
-        if (deps != null) {
-            for (const alias in deps) {
-                const rawRef = deps[alias];
-                // Lockfile may expose ref as string (version) or inline { version, specifier }
-                const ref = typeof rawRef === 'string'
-                    ? rawRef
-                    : rawRef?.version;
-                if (ref == null)
-                    continue;
-                if (nodeId.type === 'package' && isPeerSatisfactionEdge(opts.peerSatisfactionEdges, nodeId.depPath, alias))
-                    continue;
-                const targetNodeId = getTreeNodeChildId({
-                    parentId: nodeId,
-                    dep: { alias, ref },
-                    lockfileDir: opts.lockfileDir,
-                    importers: opts.importers,
-                });
-                const target = targetNodeId != null
-                    ? { id: serializeTreeNodeId(targetNodeId), nodeId: targetNodeId }
-                    : undefined;
-                const edge = { alias, ref, target };
-                if (opts.onlyProjects && !isProjectEdge(nodeId, edge)) {
-                    continue;
-                }
-                edges.push(edge);
-                if (target && !visited.has(target.id)) {
-                    queue.push(target.nodeId);
-                }
+        const graphNode = createGraphNode(nodeId, opts);
+        for (const { target } of graphNode.edges) {
+            if (target && !visited.has(target.id)) {
+                queue.push(target.nodeId);
             }
         }
-        graph.nodes.set(serialized, { nodeId, edges, peers });
+        graph.nodes.set(serialized, graphNode);
     }
     return graph;
 }
+function createGraphNode(nodeId, opts) {
+    const snapshot = getSnapshot(nodeId, opts);
+    if (!snapshot) {
+        return { nodeId, edges: [], peers: new Set() };
+    }
+    // For importers, only include the dependency fields the caller selected.
+    // For packages, devDependencies don't exist in the lockfile.
+    const deps = nodeId.type === 'importer'
+        ? selectImporterDependencies(snapshot, opts.include)
+        : selectPackageDependencies(snapshot, opts.include);
+    const peers = new Set(Object.keys(nodeId.type === 'package'
+        ? (opts.currentPackages[nodeId.depPath]?.peerDependencies ?? {})
+        : {}));
+    return { nodeId, edges: createEdges(nodeId, deps, opts), peers };
+}
+function selectImporterDependencies(snapshot, include) {
+    return {
+        ...(include.dependencies !== false ? snapshot.dependencies : undefined),
+        ...(include.devDependencies !== false ? snapshot.devDependencies : undefined),
+        ...(include.dependencies !== false && include.optionalDependencies ? snapshot.optionalDependencies : undefined),
+    };
+}
+function selectPackageDependencies(snapshot, include) {
+    if (!include.optionalDependencies)
+        return snapshot.dependencies;
+    return {
+        ...snapshot.dependencies,
+        ...snapshot.optionalDependencies,
+    };
+}
+function createEdges(nodeId, deps, opts) {
+    const edges = [];
+    if (deps == null)
+        return edges;
+    for (const alias in deps) {
+        const edge = createEdge(nodeId, { alias, rawRef: deps[alias] }, opts);
+        if (edge == null)
+            continue;
+        if (opts.onlyProjects && !isProjectEdge(nodeId, edge)) {
+            continue;
+        }
+        edges.push(edge);
+    }
+    return edges;
+}
+function createEdge(nodeId, { alias, rawRef }, opts) {
+    // Lockfile may expose ref as string (version) or inline { version, specifier }
+    const ref = typeof rawRef === 'string'
+        ? rawRef
+        : rawRef?.version;
+    if (ref == null)
+        return undefined;
+    if (nodeId.type === 'package' && isPeerSatisfactionEdge(opts.peerSatisfactionEdges, nodeId.depPath, alias))
+        return undefined;
+    const targetNodeId = getTreeNodeChildId({
+        parentId: nodeId,
+        dep: { alias, ref },
+        lockfileDir: opts.lockfileDir,
+        importers: opts.importers,
+    });
+    const target = targetNodeId != null
+        ? { id: serializeTreeNodeId(targetNodeId), nodeId: targetNodeId }
+        : undefined;
+    return { alias, ref, target };
+}
 /**
  * Whether an edge may lead to a project. Besides the importers of the lockfile,
  * this includes a project's `link:` dependency on a directory outside the

package/lib/buildDependentsTree.d.ts

@@ -28,7 +28,12 @@ export interface ImporterInfo {
     name: string;
     version: string;
 }
-export declare function buildDependentsTree(packages: string[], projectPaths: string[], opts: {
+type NameFormatter = (info: {
+    name: string;
+    version: string;
+    manifest: DependencyManifest;
+}) => string | undefined;
+interface BuildDependentsTreeOptions {
     lockfileDir: string;
     include?: {
         [field in DependenciesField]?: boolean;
@@ -39,10 +44,8 @@ export declare function buildDependentsTree(packages: string[], projectPaths: st
     finders?: Finder[];
     importerInfoMap: Map<string, ImporterInfo>;
     lockfile: LockfileObject;
-    nameFormatter?: (info: {
-        name: string;
-        version: string;
-        manifest: DependencyManifest;
-    }) => string | undefined;
+    nameFormatter?: NameFormatter;
     resolvePeersFromWorkspaceRoot?: boolean;
-}): Promise<DependentsTree[]>;
+}
+export declare function buildDependentsTree(packages: string[], projectPaths: string[], opts: BuildDependentsTreeOptions): Promise<DependentsTree[]>;
+export {};