@pnpm/installing.deps-resolver 1008.3.1

package/lib/resolveDependencyTree.d.ts

@@ -0,0 +1,122 @@
+import type { Catalogs } from '@pnpm/catalogs.types';
+import type { LockfileObject } from '@pnpm/lockfile.types';
+import type { PatchGroupRecord } from '@pnpm/patching.config';
+import type { PreferredVersions, Resolution, WorkspacePackages } from '@pnpm/resolving.resolver-base';
+import type { StoreController } from '@pnpm/store.controller-types';
+import type { AllowBuild, AllowedDeprecatedVersions, PinnedVersion, PkgResolutionId, ProjectId, ProjectManifest, ProjectRootDir, ReadPackageHook, Registries, SupportedArchitectures, TrustPolicy } from '@pnpm/types';
+import type { WantedDependency } from './getNonDevWantedDependencies.js';
+import { type NodeId } from './nextNodeId.js';
+import { type DependenciesTree, type LinkedDependency, type ResolvedPackage, type ResolvedPkgsById } from './resolveDependencies.js';
+export type { DependenciesTree, DependenciesTreeNode, LinkedDependency, ResolvedPackage } from './resolveDependencies.js';
+export interface ResolvedImporters {
+    [id: string]: {
+        directDependencies: ResolvedDirectDependency[];
+        directNodeIdsByAlias: Map<string, NodeId>;
+        linkedDependencies: LinkedDependency[];
+    };
+}
+export interface ResolvedDirectDependency {
+    alias: string;
+    optional: boolean;
+    dev: boolean;
+    resolution: Resolution;
+    pkgId: PkgResolutionId;
+    version: string;
+    name: string;
+    catalogLookup?: CatalogLookupMetadata;
+    normalizedBareSpecifier?: string;
+}
+/**
+ * Information related to the catalog entry for this dependency if it was
+ * requested through the catalog protocol.
+ */
+export interface CatalogLookupMetadata {
+    readonly catalogName: string;
+    readonly specifier: string;
+    /**
+     * The catalog protocol bareSpecifier the user wrote in package.json files or as a
+     * parameter to pnpm add. Ex: pnpm add foo@catalog:
+     *
+     * This will usually be 'catalog:<name>', but can simply be 'catalog:' if
+     * users wrote the default catalog shorthand. This is different than the
+     * catalogName field, which would be 'default' regardless of whether users
+     * originally requested 'catalog:' or 'catalog:default'.
+     */
+    readonly userSpecifiedBareSpecifier: string;
+}
+export interface Importer<WantedDepExtraProps> {
+    id: ProjectId;
+    manifest: ProjectManifest;
+    modulesDir: string;
+    removePackages?: string[];
+    rootDir: ProjectRootDir;
+    wantedDependencies: Array<WantedDepExtraProps & WantedDependency>;
+}
+export interface ImporterToResolveGeneric<WantedDepExtraProps> extends Importer<WantedDepExtraProps> {
+    updatePackageManifest: boolean;
+    updateMatching?: (pkgName: string, version?: string) => boolean;
+    updateToLatest?: boolean;
+    hasRemovedDependencies?: boolean;
+    preferredVersions?: PreferredVersions;
+    wantedDependencies: Array<WantedDepExtraProps & WantedDependency & {
+        updateDepth: number;
+    }>;
+    pinnedVersion?: PinnedVersion;
+}
+export interface ResolveDependenciesOptions {
+    allowBuild?: AllowBuild;
+    autoInstallPeers?: boolean;
+    autoInstallPeersFromHighestMatch?: boolean;
+    allowedDeprecatedVersions: AllowedDeprecatedVersions;
+    allowUnusedPatches: boolean;
+    catalogs?: Catalogs;
+    currentLockfile: LockfileObject;
+    dedupePeerDependents?: boolean;
+    dryRun: boolean;
+    engineStrict: boolean;
+    force: boolean;
+    forceFullResolution: boolean;
+    ignoreScripts?: boolean;
+    hooks: {
+        readPackage?: ReadPackageHook;
+    };
+    nodeVersion?: string;
+    registries: Registries;
+    patchedDependencies?: PatchGroupRecord;
+    pnpmVersion: string;
+    preferredVersions?: PreferredVersions;
+    preferWorkspacePackages?: boolean;
+    resolutionMode?: 'highest' | 'time-based' | 'lowest-direct';
+    resolvePeersFromWorkspaceRoot?: boolean;
+    injectWorkspacePackages?: boolean;
+    linkWorkspacePackagesDepth?: number;
+    lockfileDir: string;
+    storeController: StoreController;
+    tag: string;
+    virtualStoreDir: string;
+    globalVirtualStoreDir: string;
+    virtualStoreDirMaxLength: number;
+    wantedLockfile: LockfileObject;
+    workspacePackages: WorkspacePackages;
+    supportedArchitectures?: SupportedArchitectures;
+    peersSuffixMaxLength: number;
+    minimumReleaseAge?: number;
+    minimumReleaseAgeExclude?: string[];
+    trustPolicy?: TrustPolicy;
+    trustPolicyExclude?: string[];
+    trustPolicyIgnoreAfter?: number;
+    blockExoticSubdeps?: boolean;
+}
+export interface ResolveDependencyTreeResult {
+    allPeerDepNames: Set<string>;
+    dependenciesTree: DependenciesTree<ResolvedPackage>;
+    outdatedDependencies: {
+        [pkgId: string]: string;
+    };
+    resolvedImporters: ResolvedImporters;
+    resolvedPkgsById: ResolvedPkgsById;
+    wantedToBeSkippedPackageIds: Set<string>;
+    appliedPatches: Set<string>;
+    time?: Record<string, string>;
+}
+export declare function resolveDependencyTree<T>(importers: Array<ImporterToResolveGeneric<T>>, opts: ResolveDependenciesOptions): Promise<ResolveDependencyTreeResult>;

package/lib/resolveDependencyTree.js

@@ -0,0 +1,228 @@
+import { resolveFromCatalog } from '@pnpm/catalogs.resolver';
+import { createPackageVersionPolicy } from '@pnpm/config.version-policy';
+import { PnpmError } from '@pnpm/error';
+import { globalWarn } from '@pnpm/logger';
+import { partition, zipObj } from 'ramda';
+import { nextNodeId } from './nextNodeId.js';
+import { parentIdsContainSequence } from './parentIdsContainSequence.js';
+import { resolveRootDependencies, } from './resolveDependencies.js';
+export async function resolveDependencyTree(importers, opts) {
+    const wantedToBeSkippedPackageIds = new Set();
+    const autoInstallPeers = opts.autoInstallPeers === true;
+    const ctx = {
+        allowBuild: opts.allowBuild,
+        autoInstallPeers,
+        autoInstallPeersFromHighestMatch: opts.autoInstallPeersFromHighestMatch === true,
+        allowedDeprecatedVersions: opts.allowedDeprecatedVersions,
+        catalogResolver: resolveFromCatalog.bind(null, opts.catalogs ?? {}),
+        childrenByParentId: {},
+        currentLockfile: opts.currentLockfile,
+        defaultTag: opts.tag,
+        dependenciesTree: new Map(),
+        dryRun: opts.dryRun,
+        engineStrict: opts.engineStrict,
+        force: opts.force,
+        forceFullResolution: opts.forceFullResolution,
+        ignoreScripts: opts.ignoreScripts,
+        injectWorkspacePackages: opts.injectWorkspacePackages,
+        linkWorkspacePackagesDepth: opts.linkWorkspacePackagesDepth ?? -1,
+        lockfileDir: opts.lockfileDir,
+        nodeVersion: opts.nodeVersion,
+        outdatedDependencies: {},
+        patchedDependencies: opts.patchedDependencies,
+        pendingNodes: [],
+        pnpmVersion: opts.pnpmVersion,
+        preferWorkspacePackages: opts.preferWorkspacePackages,
+        readPackageHook: opts.hooks.readPackage,
+        registries: opts.registries,
+        resolvedPkgsById: {},
+        resolvePeersFromWorkspaceRoot: opts.resolvePeersFromWorkspaceRoot,
+        resolutionMode: opts.resolutionMode,
+        skipped: wantedToBeSkippedPackageIds,
+        storeController: opts.storeController,
+        virtualStoreDir: opts.virtualStoreDir,
+        virtualStoreDirMaxLength: opts.virtualStoreDirMaxLength,
+        wantedLockfile: opts.wantedLockfile,
+        appliedPatches: new Set(),
+        updatedSet: new Set(),
+        workspacePackages: opts.workspacePackages,
+        missingPeersOfChildrenByPkgId: {},
+        hoistPeers: autoInstallPeers || opts.dedupePeerDependents,
+        allPeerDepNames: new Set(),
+        maximumPublishedBy: opts.minimumReleaseAge ? new Date(Date.now() - opts.minimumReleaseAge * 60 * 1000) : undefined,
+        publishedByExclude: opts.minimumReleaseAgeExclude ? createPackageVersionPolicyByExclude(opts.minimumReleaseAgeExclude, 'minimumReleaseAgeExclude') : undefined,
+        trustPolicy: opts.trustPolicy,
+        trustPolicyExclude: opts.trustPolicyExclude ? createPackageVersionPolicyByExclude(opts.trustPolicyExclude, 'trustPolicyExclude') : undefined,
+        trustPolicyIgnoreAfter: opts.trustPolicyIgnoreAfter,
+        blockExoticSubdeps: opts.blockExoticSubdeps,
+    };
+    function createPackageVersionPolicyByExclude(patterns, key) {
+        try {
+            return createPackageVersionPolicy(patterns);
+        }
+        catch (err) {
+            if (!err || typeof err !== 'object' || !('message' in err))
+                throw err;
+            throw new PnpmError(`INVALID_${key.replace(/([A-Z])/g, '_$1').toUpperCase()}`, `Invalid value in ${key}: ${err.message}`);
+        }
+    }
+    const resolveArgs = importers.map((importer) => {
+        const projectSnapshot = opts.wantedLockfile.importers[importer.id];
+        // This may be optimized.
+        // We only need to proceed resolving every dependency
+        // if the newly added dependency has peer dependencies.
+        const proceed = importer.id === '.' || importer.hasRemovedDependencies === true || importer.wantedDependencies.some((wantedDep) => wantedDep.isNew); // eslint-disable-line @typescript-eslint/no-explicit-any
+        const resolveOpts = {
+            currentDepth: 0,
+            parentPkg: {
+                installable: true,
+                nodeId: importer.id,
+                optional: false,
+                pkgId: importer.id,
+                rootDir: importer.rootDir,
+            },
+            parentIds: [importer.id],
+            proceed,
+            resolvedDependencies: {
+                ...projectSnapshot.dependencies,
+                ...projectSnapshot.devDependencies,
+                ...projectSnapshot.optionalDependencies,
+            },
+            updateDepth: -1,
+            updateMatching: importer.updateMatching,
+            updateToLatest: importer.updateToLatest,
+            prefix: importer.rootDir,
+            supportedArchitectures: opts.supportedArchitectures,
+        };
+        return {
+            updatePackageManifest: importer.updatePackageManifest,
+            parentPkgAliases: Object.fromEntries(importer.wantedDependencies.filter(({ alias }) => alias).map(({ alias }) => [alias, true])),
+            preferredVersions: importer.preferredVersions ?? {},
+            wantedDependencies: importer.wantedDependencies,
+            options: resolveOpts,
+            pinnedVersion: importer.pinnedVersion,
+        };
+    });
+    const { pkgAddressesByImporters, time } = await resolveRootDependencies(ctx, resolveArgs);
+    const directDepsByImporterId = zipObj(importers.map(({ id }) => id), pkgAddressesByImporters);
+    for (const directDependencies of pkgAddressesByImporters) {
+        for (const directDep of directDependencies) {
+            const { alias, normalizedBareSpecifier, version, saveCatalogName } = directDep;
+            if (saveCatalogName == null) {
+                continue;
+            }
+            const existingCatalog = opts.catalogs?.default?.[alias];
+            if (existingCatalog != null) {
+                if (existingCatalog !== normalizedBareSpecifier) {
+                    globalWarn(`Skip adding ${alias} to the default catalog because it already exists as ${existingCatalog}. Please use \`pnpm update\` to update the catalogs.`);
+                }
+            }
+            else if (normalizedBareSpecifier != null && version != null) {
+                const userSpecifiedBareSpecifier = `catalog:${saveCatalogName === 'default' ? '' : saveCatalogName}`;
+                // Attach metadata about how this new catalog dependency should be
+                // resolved so the pnpm-lock.yaml file's catalogs section can be updated
+                // to reflect this newly added entry.
+                directDep.catalogLookup = {
+                    catalogName: saveCatalogName,
+                    specifier: normalizedBareSpecifier,
+                    userSpecifiedBareSpecifier,
+                };
+            }
+        }
+    }
+    for (const pendingNode of ctx.pendingNodes) {
+        ctx.dependenciesTree.set(pendingNode.nodeId, {
+            children: () => buildTree(ctx, pendingNode.resolvedPackage.id, pendingNode.parentIds, ctx.childrenByParentId[pendingNode.resolvedPackage.id], pendingNode.depth + 1, pendingNode.installable),
+            depth: pendingNode.depth,
+            installable: pendingNode.installable,
+            resolvedPackage: pendingNode.resolvedPackage,
+        });
+    }
+    const resolvedImporters = {};
+    for (const { id, wantedDependencies } of importers) {
+        const directDeps = dedupeSameAliasDirectDeps(directDepsByImporterId[id], wantedDependencies);
+        const [linkedDependencies, directNonLinkedDeps] = partition((dep) => dep.isLinkedDependency === true, directDeps);
+        resolvedImporters[id] = {
+            directDependencies: directDeps
+                .map((dep) => {
+                if (dep.isLinkedDependency === true) {
+                    return dep;
+                }
+                const resolvedPackage = ctx.dependenciesTree.get(dep.nodeId).resolvedPackage;
+                return {
+                    alias: dep.alias,
+                    catalogLookup: dep.catalogLookup,
+                    dev: resolvedPackage.dev,
+                    name: resolvedPackage.name,
+                    optional: resolvedPackage.optional,
+                    pkgId: resolvedPackage.id,
+                    resolution: resolvedPackage.resolution,
+                    version: resolvedPackage.version,
+                    normalizedBareSpecifier: dep.normalizedBareSpecifier,
+                };
+            }),
+            directNodeIdsByAlias: new Map(directNonLinkedDeps.map(({ alias, nodeId }) => [alias, nodeId])),
+            linkedDependencies,
+        };
+    }
+    return {
+        dependenciesTree: ctx.dependenciesTree,
+        outdatedDependencies: ctx.outdatedDependencies,
+        resolvedImporters,
+        resolvedPkgsById: ctx.resolvedPkgsById,
+        wantedToBeSkippedPackageIds,
+        appliedPatches: ctx.appliedPatches,
+        time,
+        allPeerDepNames: ctx.allPeerDepNames,
+    };
+}
+function buildTree(ctx, parentId, parentIds, children, depth, installable) {
+    const childrenNodeIds = {};
+    for (const child of children) {
+        if (child.id.startsWith('link:')) {
+            childrenNodeIds[child.alias] = child.id;
+            continue;
+        }
+        if (parentIdsContainSequence(parentIds, parentId, child.id) || parentId === child.id) {
+            continue;
+        }
+        if (ctx.resolvedPkgsById[child.id].isLeaf) {
+            childrenNodeIds[child.alias] = child.id;
+            continue;
+        }
+        const childNodeId = nextNodeId();
+        childrenNodeIds[child.alias] = childNodeId;
+        installable = installable || !ctx.skipped.has(child.id);
+        ctx.dependenciesTree.set(childNodeId, {
+            children: () => buildTree(ctx, child.id, [...parentIds, child.id], ctx.childrenByParentId[child.id], depth + 1, installable),
+            depth,
+            installable,
+            resolvedPackage: ctx.resolvedPkgsById[child.id],
+        });
+    }
+    return childrenNodeIds;
+}
+/**
+  * There may be cases where multiple dependencies have the same alias in the directDeps array.
+  * E.g., when there is "is-negative: github:kevva/is-negative#1.0.0" in the package.json dependencies,
+  * and then re-execute `pnpm add github:kevva/is-negative#1.0.1`.
+  * In order to make sure that the latest 1.0.1 version is installed, we need to remove the duplicate dependency.
+  * fix https://github.com/pnpm/pnpm/issues/6966
+  */
+function dedupeSameAliasDirectDeps(directDeps, wantedDependencies) {
+    const deps = new Map();
+    for (const directDep of directDeps) {
+        const { alias, normalizedBareSpecifier } = directDep;
+        if (!deps.has(alias)) {
+            deps.set(alias, directDep);
+        }
+        else {
+            const wantedDep = wantedDependencies.find(dep => dep.alias ? dep.alias === alias : dep.bareSpecifier === normalizedBareSpecifier);
+            if (wantedDep?.isNew) {
+                deps.set(alias, directDep);
+            }
+        }
+    }
+    return Array.from(deps.values());
+}
+//# sourceMappingURL=resolveDependencyTree.js.map

package/lib/resolvePeers.d.ts

@@ -0,0 +1,59 @@
+import type { DepPath, PeerDependencyIssuesByProjects, ProjectRootDir } from '@pnpm/types';
+import type { NodeId } from './nextNodeId.js';
+import type { DependenciesTree, PeerDependencies, ResolvedPackage } from './resolveDependencies.js';
+import type { ResolvedImporters } from './resolveDependencyTree.js';
+export interface BaseGenericDependenciesGraphNode {
+    modules: string;
+    dir: string;
+    depPath: DepPath;
+    depth: number;
+    peerDependencies?: PeerDependencies;
+    transitivePeerDependencies: Set<string>;
+    installable: boolean;
+    isBuilt?: boolean;
+    isPure: boolean;
+    resolvedPeerNames: Set<string>;
+    requiresBuild?: boolean;
+}
+export interface GenericDependenciesGraphNode extends BaseGenericDependenciesGraphNode {
+    childrenNodeIds: Record<string, NodeId>;
+}
+export interface GenericDependenciesGraphNodeWithResolvedChildren extends BaseGenericDependenciesGraphNode {
+    children: Record<string, DepPath>;
+}
+export type PartialResolvedPackage = Pick<ResolvedPackage, 'id' | 'pkgIdWithPatchHash' | 'name' | 'peerDependencies' | 'version'>;
+export interface GenericDependenciesGraph<T extends PartialResolvedPackage> {
+    [depPath: DepPath]: T & GenericDependenciesGraphNode;
+}
+export interface GenericDependenciesGraphWithResolvedChildren<T extends PartialResolvedPackage> {
+    [depPath: DepPath]: T & GenericDependenciesGraphNodeWithResolvedChildren;
+}
+export interface ProjectToResolve {
+    directNodeIdsByAlias: Map<string, NodeId>;
+    topParents: Array<{
+        name: string;
+        version: string;
+        alias?: string;
+    }>;
+    rootDir: ProjectRootDir;
+    id: string;
+}
+export type DependenciesByProjectId = Record<string, Map<string, DepPath>>;
+export declare function resolvePeers<T extends PartialResolvedPackage>(opts: {
+    allPeerDepNames: Set<string>;
+    projects: ProjectToResolve[];
+    dependenciesTree: DependenciesTree<T>;
+    virtualStoreDir: string;
+    virtualStoreDirMaxLength: number;
+    lockfileDir: string;
+    resolvePeersFromWorkspaceRoot?: boolean;
+    dedupePeerDependents?: boolean;
+    dedupeInjectedDeps?: boolean;
+    resolvedImporters: ResolvedImporters;
+    peersSuffixMaxLength: number;
+    workspaceProjectIds: Set<string>;
+}): Promise<{
+    dependenciesGraph: GenericDependenciesGraphWithResolvedChildren<T>;
+    dependenciesByProjectId: DependenciesByProjectId;
+    peerDependencyIssuesByProjects: PeerDependencyIssuesByProjects;
+}>;