How peers are resolved

One of the best features of pnpm is that in one project, a specific version of a package will always have one set of dependencies. There is one exception from this rule, though - packages with peer dependencies.

Peer dependencies are resolved from dependencies installed higher in the dependency graph, since they share the same version as their parent. That means that if foo@1.0.0 has two peers (bar@^1 and baz@^1) then it might have multiple different sets of dependencies in the same project.

  1. - foo-parent-1
  2.   - bar@1.0.0
  3.   - baz@1.0.0
  4.   - foo@1.0.0
  5. - foo-parent-2
  6.   - bar@1.0.0
  7.   - baz@1.1.0
  8.   - foo@1.0.0

In the example above, foo@1.0.0 is installed for foo-parent-1 and foo-parent-2. Both packages have bar and baz as well, but they depend on different versions of baz. As a result, foo@1.0.0 has two different sets of dependencies: one with baz@1.0.0 and the other one with baz@1.1.0. To support these use cases, pnpm has to hard link foo@1.0.0 as many times as there are different dependency sets.

Normally, if a package does not have peer dependencies, it is hard linked to a node_modules folder next to symlinks of its dependencies, like so:

  1. node_modules
  2. └── .pnpm
  3.     ├── foo@1.0.0
  4.     │   └── node_modules
  5.     │       ├── foo
  6.     │       ├── qux   -> ../../qux@1.0.0/node_modules/qux
  7.     │       └── plugh -> ../../plugh@1.0.0/node_modules/plugh
  8.     ├── qux@1.0.0
  9.     ├── plugh@1.0.0

However, if foo has peer dependencies, there may be multiple sets of dependencies for it, so we create different sets for different peer dependency resolutions:

  1. node_modules
  2. └── .pnpm
  3.     ├── foo@1.0.0_bar@1.0.0+baz@1.0.0
  4.     │   └── node_modules
  5.     │       ├── foo
  6.     │       ├── bar   -> ../../bar@1.0.0/node_modules/bar
  7.     │       ├── baz   -> ../../baz@1.0.0/node_modules/baz
  8.     │       ├── qux   -> ../../qux@1.0.0/node_modules/qux
  9.     │       └── plugh -> ../../plugh@1.0.0/node_modules/plugh
  10.     ├── foo@1.0.0_bar@1.0.0+baz@1.1.0
  11.     │   └── node_modules
  12.     │       ├── foo
  13.     │       ├── bar   -> ../../bar@1.0.0/node_modules/bar
  14.     │       ├── baz   -> ../../baz@1.1.0/node_modules/baz
  15.     │       ├── qux   -> ../../qux@1.0.0/node_modules/qux
  16.     │       └── plugh -> ../../plugh@1.0.0/node_modules/plugh
  17.     ├── bar@1.0.0
  18.     ├── baz@1.0.0
  19.     ├── baz@1.1.0
  20.     ├── qux@1.0.0
  21.     ├── plugh@1.0.0

We create symlinks either to the foo that is inside foo@1.0.0_bar@1.0.0+baz@1.0.0 or to the one in foo@1.0.0_bar@1.0.0+baz@1.1.0. As a consequence, the Node.js module resolver will find the correct peers.

If a package has no peer dependencies but has dependencies with peers that are resolved higher in the graph, then that transitive package can appear in the project with different sets of dependencies. For instance, there’s package a@1.0.0 with a single dependency b@1.0.0. b@1.0.0 has a peer dependency c@^1. a@1.0.0 will never resolve the peers of b@1.0.0, so it becomes dependent from the peers of b@1.0.0 as well.

Here’s how that structure will look in node_modules. In this example, a@1.0.0 will need to appear twice in the project’s node_modules - resolved once with c@1.0.0 and again with c@1.1.0.

  1. node_modules
  2. └── .pnpm
  3.     ├── a@1.0.0_c@1.0.0
  4.     │   └── node_modules
  5.     │       ├── a
  6.     │       └── b -> ../../b@1.0.0_c@1.0.0/node_modules/b
  7.     ├── a@1.0.0_c@1.1.0
  8.     │   └── node_modules
  9.     │       ├── a
  10.     │       └── b -> ../../b@1.0.0_c@1.1.0/node_modules/b
  11.     ├── b@1.0.0_c@1.0.0
  12.     │   └── node_modules
  13.     │       ├── b
  14.     │       └── c -> ../../c@1.0.0/node_modules/c
  15.     ├── b@1.0.0_c@1.1.0
  16.     │   └── node_modules
  17.     │       ├── b
  18.     │       └── c -> ../../c@1.1.0/node_modules/c
  19.     ├── c@1.0.0
  20.     ├── c@1.1.0