feat(dependency-resolver): opt-in support for pnpm's global virtual store

components/legacy/constants/constants.ts

@@ -360,6 +360,12 @@ export const CFG_CAPSULES_ROOT_BASE_DIR = 'capsules_root_base_dir';
 
 export const CFG_ISOLATED_SCOPE_CAPSULES = 'isolated_scope_capsules';
 
+/**
+ * Opt in to pnpm's global virtual store for every workspace and capsule on this machine.
+ * A workspace can still override it through `teambit.dependencies/dependency-resolver`.
+ */
+export const CFG_ENABLE_GLOBAL_VIRTUAL_STORE = 'enable_global_virtual_store';
+
 /**
  * Name of the directory where the capsules for building components are stored
  * This is used for the components capsules for bit build / tag / snap / sign

components/legacy/e2e-helper/e2e-fs-helper.ts

@@ -3,7 +3,10 @@ import fs from 'fs-extra';
 import { use, expect } from 'chai';
 import { globSync } from 'glob';
 import * as path from 'path';
+import * as yaml from 'yaml';
+import resolveFrom from 'resolve-from';
 import { generateRandomStr } from '@teambit/toolbox.string.random';
+import { depPathToDirName } from '@teambit/dependencies.pnpm.dep-path';
 import * as fixtures from './fixtures';
 import { ensureAndWriteJson } from './e2e-helper';
 import type ScopesData from './e2e-scopes';
@@ -26,6 +29,49 @@ export default class FsHelper {
 
     return globSync(path.normalize(`**/${ext}`), params).map((x) => path.normalize(x));
   }
+  /**
+   * Walk a chain of package names the way Node resolves them - each name is resolved from the real
+   * directory of the one before it - and return the last one's directory.
+   *
+   * Use this instead of hand-writing a path into `node_modules/.pnpm/<depPath>/node_modules/<dep>`:
+   * that spelling only exists in the project-local virtual store. Under the global virtual store the
+   * package lives in a hash-named directory in the shared store, and under a hoisted `nodeLinker` it
+   * is nested in `node_modules` - resolution finds the right copy in all three.
+   */
+  resolvePackageDir(chain: string[], workspacePath: string = this.scopes.localPath): string {
+    let dir = workspacePath;
+    for (const packageName of chain) {
+      dir = path.dirname(fs.realpathSync(resolveFrom(dir, `${packageName}/package.json`)));
+    }
+    return dir;
+  }
+
+  /** The `package.json` of the package at the end of a `resolvePackageDir` chain. */
+  readPackageJsonOfChain(chain: string[], workspacePath?: string): Record<string, any> {
+    return fs.readJsonSync(path.join(this.resolvePackageDir(chain, workspacePath), 'package.json'));
+  }
+
+  /**
+   * The dependency directories the last install materialized, named the way `node_modules/.pnpm`
+   * names them (`@scope+name@version`).
+   *
+   * With the global virtual store enabled those directories live in the shared store instead of
+   * `node_modules/.pnpm`, and the shared store holds every workspace's packages - so the equivalent
+   * per-workspace list comes from the current lockfile the install writes next to them.
+   */
+  getVirtualStoreDirNames(workspacePath: string = this.scopes.localPath): string[] {
+    const virtualStoreDir = path.join(workspacePath, 'node_modules/.pnpm');
+    if (!fs.existsSync(virtualStoreDir)) return [];
+    const dirs = fs
+      .readdirSync(virtualStoreDir)
+      .filter((dirName) => dirName !== 'lock.yaml' && dirName !== 'node_modules');
+    if (dirs.length) return dirs;
+    const currentLockfile = path.join(virtualStoreDir, 'lock.yaml');
+    if (!fs.existsSync(currentLockfile)) return dirs;
+    const lockfile = yaml.parse(fs.readFileSync(currentLockfile, 'utf8'));
+    return Object.keys(lockfile?.packages ?? {}).map((depPath: string) => depPathToDirName(depPath));
+  }
+
   getObjectFiles() {
     return globSync(path.normalize('*/*'), { cwd: path.join(this.scopes.localPath, '.bit/objects') });
   }

components/legacy/e2e-helper/excluded-fixtures/workspace-with-tsconfig-issue/my-scope/envs/my-react-env/my-react-env.bit-env.ts

@@ -1,4 +1,3 @@
-// @bit-no-check
 // @ts-nocheck
 
 /**

components/overview/renderers/grouped-schema-nodes-overview-summary/grouped-schema-nodes-overview-summary.tsx

@@ -135,7 +135,9 @@ export function SchemaNodesSummary({
                     headings={_headings}
                   />
                   {groupedMembersByType.map((member) => {
-                    // @ts-expect-error - version skew: local SchemaNode has diff() but npm-published version doesn't yet
+                    // @ts-ignore - version skew: local SchemaNode has diff() but the npm-published one doesn't yet.
+                    // Only errors in the capsule build, where two semantic-schema versions genuinely coexist; the
+                    // workspace type-check resolves a single copy (tsconfig paths), so @ts-expect-error would be unused there.
                     return renderTable(type ?? '', member, _headings);
                   })}
                 </div>
@@ -146,7 +148,8 @@ export function SchemaNodesSummary({
                 {groupedMembersByType.map((member) => (
                   <SchemaMethodMember
                     key={`${member.__schema}-${member.name}`}
-                    // @ts-expect-error - version skew: local SchemaNode has diff() but npm-published version doesn't yet
+                    // @ts-ignore - version skew: local SchemaNode has diff() but the npm-published one doesn't yet.
+                    // Only errors in the capsule build (two semantic-schema versions); unused in the workspace type-check.
                     member={member}
                     apiNodeRendererProps={apiNodeRendererProps}
                   />

components/ui/component-compare/component-compare/component-compare.tsx

@@ -375,12 +375,17 @@ export function ComponentCompare(props: ComponentCompareProps) {
   const skipComponentCompareQuery =
     hidden || (base?.id.version?.toString() === compare?.id.version?.toString() && !compareIsLocalChanges);
 
-  const { loading: compCompareLoading, componentCompareData } = useComponentCompareQuery(
+  const { loading: compCompareLoading, componentCompareData: componentCompareDataRaw } = useComponentCompareQuery(
     base?.id.toString(),
     compare?.id.toString(),
     undefined,
     skipComponentCompareQuery
   );
+  // version skew: the GraphQL response carries `tests`, the npm-published
+  // ComponentCompareQueryResponse doesn't declare it yet
+  const componentCompareData = componentCompareDataRaw as
+    | (typeof componentCompareDataRaw & { tests?: Array<FileCompareResult & { fileName: string }> })
+    | undefined;
 
   const { loading: apiDiffLoading, result: apiDiffResult } = useApiDiff(base?.id.toString(), compare?.id.toString(), {
     skip: hidden,

components/ui/component-meta/component-overview.tsx

@@ -87,7 +87,12 @@ export function ComponentOverview({
     }
   }, [selectedPkgManager]);
 
-  const tabsComponentId: ContentTab[] = [
+  // version skew: the published Tab type gained `content?: string`, which intersects
+  // ContentTab's `content: ReactNode` into `ReactNode & string` - impossible to satisfy with an
+  // element, though elements are the intended usage. Build with the corrected member and cast
+  // once where the array is handed over.
+  type ContentTabFixed = Omit<ContentTab, 'content'> & { content: React.ReactNode };
+  const tabsComponentId: ContentTabFixed[] = [
     {
       component: function TabPackageName() {
         return <span>{packageNameTabTitle}</span>;
@@ -262,7 +267,12 @@ export function ComponentOverview({
         </Row>
         <Row>
           <div className={styles.contentTabs}>
-            <ContentTabs priority="folder" tabs={tabsComponentId} navClassName={styles.nav} tabClassName={styles.tab} />
+            <ContentTabs
+              priority="folder"
+              tabs={tabsComponentId as ContentTab[]}
+              navClassName={styles.nav}
+              tabClassName={styles.tab}
+            />
           </div>
           <BadgeSection
             position={BadgePosition.Package}

e2e/harmony/dependency-resolver.e2e.ts

@@ -277,24 +277,16 @@ describe('dependency-resolver extension', function () {
       });
       it('should force a newer version of a subdependency using just the dependency name', function () {
         // Without the override, is-odd would be 0.1.2
-        expect(
-          helper.fixtures.fs.readJsonFile('node_modules/.pnpm/is-odd@1.0.0/node_modules/is-odd/package.json').version
-        ).to.eq('1.0.0');
+        expect(helper.fs.readPackageJsonOfChain(['is-even', 'is-odd']).version).to.eq('1.0.0');
       });
       it('should force a newer version of a subdependency using the dependency name and version', function () {
-        expect(
-          helper.fixtures.fs.readJsonFile('node_modules/.pnpm/glob@6.0.4/node_modules/glob/package.json').version
-        ).to.eq('6.0.4');
+        expect(helper.fs.readPackageJsonOfChain(['rimraf', 'glob']).version).to.eq('6.0.4');
       });
       it('should not change the version of the package if the parent package does not match the pattern', function () {
-        expect(
-          helper.fixtures.fs.readJsonFile('node_modules/.pnpm/glob@6.0.4/node_modules/once/package.json').version
-        ).to.eq('1.4.0');
+        expect(helper.fs.readPackageJsonOfChain(['rimraf', 'glob', 'once']).version).to.eq('1.4.0');
       });
       it('should change the version of the package if the parent package matches the pattern', function () {
-        expect(
-          helper.fixtures.fs.readJsonFile('node_modules/.pnpm/inflight@1.0.6/node_modules/once/package.json').version
-        ).to.eq('1.3.0');
+        expect(helper.fs.readPackageJsonOfChain(['rimraf', 'glob', 'inflight', 'once']).version).to.eq('1.3.0');
       });
     });
   });

e2e/harmony/global-virtual-store.e2e.ts

@@ -0,0 +1,85 @@
+import fs from 'fs-extra';
+import { expect } from 'chai';
+import path from 'path';
+import { Helper } from '@teambit/legacy.e2e-helper';
+
+/**
+ * `enableGlobalVirtualStore` moves the dependency directories out of the workspace's
+ * `node_modules/.pnpm` and into a directory shared by every workspace on the machine. Everything a
+ * workspace does has to keep working from there - the deps still have to resolve, and the envs still
+ * have to find the core aspects they require without declaring them.
+ */
+describe('installing with the global virtual store', function () {
+  let helper: Helper;
+  this.timeout(0);
+  before(() => {
+    helper = new Helper();
+  });
+  after(() => {
+    helper.scopeHelper.destroy();
+  });
+  describe('a workspace with a component', () => {
+    before(() => {
+      helper.scopeHelper.reInitWorkspace();
+      helper.extensions.workspaceJsonc.addKeyValToDependencyResolver('enableGlobalVirtualStore', true);
+      helper.fixtures.populateComponents(1);
+      helper.command.install('is-positive@1.0.0');
+    });
+    it('should not create the dependency directories inside the workspace', () => {
+      const virtualStoreDir = path.join(helper.scopes.localPath, 'node_modules/.pnpm');
+      const dirs = fs.readdirSync(virtualStoreDir).filter((dir) => dir !== 'lock.yaml' && dir !== 'node_modules');
+      expect(dirs).to.deep.eq([]);
+    });
+    it('should link the dependency from the global virtual store', () => {
+      const depPath = path.join(helper.scopes.localPath, 'node_modules/is-positive');
+      // the shared store lives outside the workspace: pnpm's own `<storeDir>/links` root
+      const realPath = fs.realpathSync(depPath);
+      expect(realPath).to.match(/[\\/]links[\\/]/);
+      expect(realPath).to.not.have.string(helper.scopes.localPath);
+    });
+    it('should still record the installed dependencies in the current lockfile', () => {
+      expect(helper.fs.getVirtualStoreDirNames()).to.include('is-positive@1.0.0');
+    });
+    it('should load the component without issues', () => {
+      const status = helper.command.statusJson();
+      expect(status.componentsWithIssues).to.have.lengthOf(0);
+    });
+    it('should compile the component into its package directory', () => {
+      helper.command.compile();
+      expect(
+        path.join(helper.scopes.localPath, 'node_modules', `@${helper.scopes.remote}/comp1/dist/index.js`)
+      ).to.be.a.path();
+    });
+  });
+  describe('patched dependencies', () => {
+    before(() => {
+      helper.scopeHelper.reInitWorkspace();
+      helper.extensions.workspaceJsonc.addKeyValToDependencyResolver('enableGlobalVirtualStore', true);
+      helper.command.install('is-positive@1.0.0');
+      // a patch's context lines are byte-exact, so build it from what was actually installed
+      const indexPath = path.join(helper.scopes.localPath, 'node_modules/is-positive/index.js');
+      const context = fs.readFileSync(indexPath, 'utf8').split('\n');
+      helper.fs.outputFile(
+        'patches/is-positive.patch',
+        [
+          'diff --git a/index.js b/index.js',
+          '--- a/index.js',
+          '+++ b/index.js',
+          `@@ -1,${context.length - 1} +1,${context.length} @@`,
+          ` ${context[0]}`,
+          '+// patched',
+          ...context.slice(1, -1).map((line) => ` ${line}`),
+          '',
+        ].join('\n')
+      );
+      helper.extensions.workspaceJsonc.addKeyValToDependencyResolver('patchedDependencies', {
+        'is-positive@1.0.0': 'patches/is-positive.patch',
+      });
+      helper.command.install();
+    });
+    it('should apply the patch to the copy in the global virtual store', () => {
+      const indexPath = path.join(helper.scopes.localPath, 'node_modules/is-positive/index.js');
+      expect(fs.readFileSync(indexPath, 'utf8')).to.include('// patched');
+    });
+  });
+});

e2e/harmony/install.e2e.ts

@@ -141,7 +141,7 @@ describe('install generator configured envs', function () {
       helper.scopeHelper.destroy();
     });
     it('should not install optional dependencies', async () => {
-      const dirs = fs.readdirSync(path.join(helper.fixtures.scopes.localPath, 'node_modules/.pnpm'));
+      const dirs = helper.fs.getVirtualStoreDirNames();
       expect(dirs).to.not.include('is-positive@1.0.0');
       expect(dirs).to.include('@pnpm.e2e+pkg-with-good-optional@1.0.0');
     });

e2e/harmony/node-linker.e2e.ts

@@ -32,7 +32,9 @@ describe('installing with non-default nodeLinker', function () {
       });
       it('should create a hoisted node_modules', function () {
         const depPath = path.join(helper.fixtures.scopes.localPath, 'node_modules/is-positive');
-        expect(fs.realpathSync(depPath)).to.contain('.pnpm');
+        // the isolated linker symlinks into a virtual store: `node_modules/.pnpm` project-locally,
+        // or `<storeDir>/bit-links/<installation>` when the global virtual store is enabled.
+        expect(fs.realpathSync(depPath)).to.match(/[\\/](\.pnpm|bit-links)[\\/]/);
       });
     });
   });