feat: allow to set a custom bit roots directory (teambit#9028)

## Proposed Changes

-
-
-

Author: zkochan

e2e/harmony/root-components.e2e.ts

@@ -1,3 +1,4 @@
+import { getRootComponentDir } from '@teambit/workspace.root-components';
 import { resolveFrom } from '@teambit/toolbox.modules.module-resolver';
 import chai, { expect } from 'chai';
 import fs from 'fs-extra';
@@ -1679,3 +1680,36 @@ describe('create with root components on', function () {
     expect(path.join(helper.env.rootCompDirDep('teambit.react/react', 'my-button'), 'index.ts')).to.be.a.path();
   });
 });
+
+describe('custom root components directory', function () {
+  let helper: Helper;
+  this.timeout(0);
+  describe('set a valid custom location', () => {
+    before(() => {
+      helper = new Helper();
+      helper.scopeHelper.setNewLocalAndRemoteScopes();
+      helper.extensions.workspaceJsonc.addKeyValToWorkspace('rootComponentsDirectory', '__bit_roots__');
+      helper.extensions.workspaceJsonc.addKeyValToDependencyResolver('rootComponents', true);
+      helper.command.create('react', 'card', '--env teambit.react/react');
+      helper.command.install();
+    });
+    it('should create the root component directory at the specified location', () => {
+      expect(
+        getRootComponentDir(path.join(helper.scopes.localPath, '__bit_roots__'), 'teambit.react/react')
+      ).to.be.a.path();
+    });
+  });
+  describe('set an invalid custom location', () => {
+    before(() => {
+      helper = new Helper();
+      helper.scopeHelper.setNewLocalAndRemoteScopes();
+      helper.extensions.workspaceJsonc.addKeyValToWorkspace('rootComponentsDirectory', '');
+      helper.extensions.workspaceJsonc.addKeyValToDependencyResolver('rootComponents', true);
+    });
+    it('should create the root component directory at the specified location', () => {
+      expect(() => helper.command.install()).throws(
+        'rootComponentsDirectory cannot be empty. Root components directory location cannot be the same as the workspace directory path'
+      );
+    });
+  });
+});

package.json

@@ -137,12 +137,12 @@
     "@teambit/harmony.modules.feature-toggle": "~0.0.4",
     "@teambit/legacy.scope-api": "~0.0.1",
     "@teambit/bit-error": "~0.0.404",
-    "@teambit/bit-roots": "~0.0.133",
     "@teambit/lane-id": "~0.0.311",
     "@teambit/component-version": "^1.0.3",
     "@teambit/toolbox.network.agent": "~0.0.554",
     "@teambit/legacy-component-log": "~0.0.402",
     "@teambit/graph.cleargraph": "0.0.11",
+    "@teambit/workspace.root-components": "1.0.0",
     "@babel/core": "7.19.6",
     "@babel/runtime": "7.23.2",
     "@teambit/legacy-bit-id": "^1.1.1",

pnpm-lock.yaml

@@ -22,7 +22,7 @@ import { DependencyResolverMain } from '@teambit/dependency-resolver';
 import { PathOsBasedAbsolute, PathOsBasedRelative } from '@teambit/toolbox.path.path';
 import { componentIdToPackageName } from '@teambit/pkg.modules.component-package-name';
 import { UiMain } from '@teambit/ui';
-import { readBitRootsDir } from '@teambit/bit-roots';
+import { readRootComponentsDir } from '@teambit/workspace.root-components';
 import { groupBy, uniq } from 'lodash';
 import type { PreStartOpts } from '@teambit/ui';
 import { MultiCompiler } from '@teambit/multi-compiler';
@@ -148,7 +148,7 @@ ${this.compileErrors.map(formatError).join('\n')}`);
     const injectedDirs = await this.workspace.getInjectedDirs(this.component);
     if (injectedDirs.length > 0) return injectedDirs;
 
-    const rootDirs = await readBitRootsDir(this.workspace.path);
+    const rootDirs = await readRootComponentsDir(this.workspace.rootComponentsPath);
     return rootDirs.map((rootDir) => path.relative(this.workspace.path, path.join(rootDir, packageName)));
   }
 

scopes/compilation/compiler/workspace-compiler.ts

@@ -2,10 +2,10 @@ import multimatch from 'multimatch';
 import mapSeries from 'p-map-series';
 import { MainRuntime } from '@teambit/cli';
 import { getAllCoreAspectsIds } from '@teambit/bit';
-import { getRelativeRootComponentDir } from '@teambit/bit-roots';
+import { getRootComponentDir } from '@teambit/workspace.root-components';
 import { ComponentAspect, Component, ComponentMap, ComponentMain, IComponent } from '@teambit/component';
 import type { ConfigMain } from '@teambit/config';
-import { join } from 'path';
+import { join, relative } from 'path';
 import { compact, get, pick, uniq, omit, cloneDeep } from 'lodash';
 import { ConfigAspect } from '@teambit/config';
 import { EnvsAspect } from '@teambit/envs';
@@ -502,18 +502,36 @@ export class DependencyResolverMain {
     return componentIdToPackageName(component.state._consumer);
   }
 
+  /*
+   * Returns the location where the component is installed with its peer dependencies inside a workspace.
+   * This is used in cases you want to actually run the components and make sure all the dependencies (especially peers) are resolved correctly
+   */
+  getRuntimeModulePathInWorkspace(component: Component, opts: { workspacePath: string; rootComponentsPath: string }) {
+    const rootComponentsRelativePath = relative(opts.workspacePath, opts.rootComponentsPath);
+    return this._getRuntimeModulePath(component, rootComponentsRelativePath);
+  }
+
+  /*
+   * Returns the location where the component is installed with its peer dependencies inside capsules.
+   * This is used in cases you want to actually run the components and make sure all the dependencies (especially peers) are resolved correctly
+   */
+  getRuntimeModulePathInCapsules(component: Component) {
+    return this._getRuntimeModulePath(component);
+  }
+
   /*
    * Returns the location where the component is installed with its peer dependencies
    * This is used in cases you want to actually run the components and make sure all the dependencies (especially peers) are resolved correctly
    */
-  getRuntimeModulePath(component: Component, isInWorkspace = false) {
+  _getRuntimeModulePath(component: Component, rootComponentsRelativePath?: string) {
     if (!this.hasRootComponents()) {
       const modulePath = this.getModulePath(component);
       return modulePath;
     }
     const pkgName = this.getPackageName(component);
+    const getRelativeRootComponentDir = getRootComponentDir.bind(null, rootComponentsRelativePath ?? '');
     const selfRootDir = getRelativeRootComponentDir(
-      !isInWorkspace ? component.id.toString() : component.id.toStringWithoutVersion()
+      rootComponentsRelativePath == null ? component.id.toString() : component.id.toStringWithoutVersion()
     );
     // In case the component is it's own root we want to load it from it's own root folder
     if (fs.pathExistsSync(selfRootDir)) {

scopes/dependencies/dependency-resolver/dependency-resolver.main.runtime.ts

@@ -2,4 +2,3 @@
 description: 'Bit command synopses. Bit version: 1.7.48'
 labels: ['cli', 'mdx', 'docs']
 ---
-      

scopes/harmony/cli-reference/cli-reference.docs.mdx

@@ -206,7 +206,7 @@ export class PkgMain {
    * This is used in cases you want to actually run the components and make sure all the dependencies (especially peers) are resolved correctly
    */
   getRuntimeModulePath(component: Component, options: GetModulePathOptions = {}) {
-    const relativePath = this.dependencyResolver.getRuntimeModulePath(component);
+    const relativePath = this.dependencyResolver.getRuntimeModulePathInCapsules(component);
     if (options?.absPath) {
       if (this.workspace) {
         return join(this.workspace.path, relativePath);

scopes/pkg/pkg/pkg.main.runtime.ts

@@ -1,6 +1,6 @@
 import fs, { pathExists } from 'fs-extra';
 import path from 'path';
-import { getRootComponentDir, getBitRootsDir, linkPkgsToBitRoots } from '@teambit/bit-roots';
+import { getRootComponentDir, linkPkgsToRootComponents } from '@teambit/workspace.root-components';
 import { CompilerMain, CompilerAspect, CompilationInitiator } from '@teambit/compiler';
 import { CLIMain, CommandList, CLIAspect, MainRuntime } from '@teambit/cli';
 import chalk from 'chalk';
@@ -614,11 +614,10 @@ export class InstallMain {
 
   private async _updateRootDirs(rootDirs: string[]) {
     try {
-      const bitRootCompsDir = getBitRootsDir(this.workspace.path);
-      const existingDirs = await fs.readdir(bitRootCompsDir);
+      const existingDirs = await fs.readdir(this.workspace.rootComponentsPath);
       await Promise.all(
         existingDirs.map(async (dirName) => {
-          const dirPath = path.join(bitRootCompsDir, dirName);
+          const dirPath = path.join(this.workspace.rootComponentsPath, dirName);
           if (!rootDirs.includes(dirPath)) {
             await fs.remove(dirPath);
           }
@@ -656,7 +655,7 @@ export class InstallMain {
       await Promise.all(
         envs.map(async (envId) => {
           return [
-            await this.getRootComponentDirByRootId(this.workspace.path, envId),
+            await this.getRootComponentDirByRootId(this.workspace.rootComponentsPath, envId),
             {
               dependencies: {
                 ...(await this._getEnvDependencies(envId)),
@@ -718,7 +717,7 @@ export class InstallMain {
             if (!appManifest) return null;
             const envId = await this.envs.calculateEnvId(app);
             return [
-              await this.getRootComponentDirByRootId(this.workspace.path, app.id),
+              await this.getRootComponentDirByRootId(this.workspace.rootComponentsPath, app.id),
               {
                 ...omit(appManifest, ['name', 'version']),
                 dependencies: {
@@ -927,23 +926,26 @@ export class InstallMain {
     const apps = (await this.app.listAppsComponents()).map((component) => component.id);
     await Promise.all(
       [...envs, ...apps].map(async (id) => {
-        const dir = await this.getRootComponentDirByRootId(this.workspace.path, id);
+        const dir = await this.getRootComponentDirByRootId(this.workspace.rootComponentsPath, id);
         await fs.mkdirp(dir);
       })
     );
-    await linkPkgsToBitRoots(
-      this.workspace.path,
+    await linkPkgsToRootComponents(
+      {
+        rootComponentsPath: this.workspace.rootComponentsPath,
+        workspacePath: this.workspace.path,
+      },
       compDirMap.components.map((component) => this.dependencyResolver.getPackageName(component))
     );
   }
 
-  private async getRootComponentDirByRootId(workspacePath: string, rootComponentId: ComponentID): Promise<string> {
+  private async getRootComponentDirByRootId(rootComponentsPath: string, rootComponentId: ComponentID): Promise<string> {
     // Root directories for local envs and apps are created without their version number.
     // This is done in order to avoid changes to the lockfile after such components are tagged.
-    const id = (await this.workspace.hasId(rootComponentId))
+    const id = this.workspace.hasId(rootComponentId)
       ? rootComponentId.toStringWithoutVersion()
       : rootComponentId.toString();
-    return getRootComponentDir(workspacePath, id);
+    return getRootComponentDir(rootComponentsPath, id);
   }
 
   /**

scopes/workspace/install/install.main.runtime.ts

@@ -1,7 +1,7 @@
 import fs from 'fs-extra';
 import pMapSeries from 'p-map-series';
 import * as path from 'path';
-import { linkPkgsToBitRoots } from '@teambit/bit-roots';
+import { linkPkgsToRootComponents } from '@teambit/workspace.root-components';
 import { ComponentID } from '@teambit/component-id';
 import { IS_WINDOWS, PACKAGE_JSON, SOURCE_DIR_SYMLINK_TO_NM } from '@teambit/legacy/dist/constants';
 import { BitMap } from '@teambit/legacy.bit-map';
@@ -69,8 +69,11 @@ export default class NodeModuleLinker {
       this.workspace.clearAllComponentsCache();
     }
 
-    await linkPkgsToBitRoots(
-      workspacePath,
+    await linkPkgsToRootComponents(
+      {
+        rootComponentsPath: this.workspace.rootComponentsPath,
+        workspacePath,
+      },
       this.components.map((comp) => componentIdToPackageName(comp.state._consumer))
     );
     return linksResults;

scopes/workspace/modules/node-modules-linker/node-modules-linker.ts

@@ -23,6 +23,12 @@ export interface WorkspaceExtConfig {
    */
   defaultDirectory: string;
 
+  /**
+   * sets the location of the root components directory.
+   * The location is a relative path to the workspace root and should use linux path separators (/).
+   */
+  rootComponentsDirectory?: string;
+
   /**
    * set the default structure of components in your project
    */

scopes/workspace/workspace/types.ts

@@ -276,6 +276,11 @@ export class Workspace implements ComponentFactory {
       );
     const defaultScope = this.config.defaultScope;
     if (!defaultScope) throw new BitError('defaultScope is missing');
+    if (this.config.rootComponentsDirectory === '') {
+      throw new BitError(
+        'rootComponentsDirectory cannot be empty. Root components directory location cannot be the same as the workspace directory path'
+      );
+    }
     if (!isValidScopeName(defaultScope)) throw new InvalidScopeName(defaultScope);
   }
 
@@ -286,6 +291,13 @@ export class Workspace implements ComponentFactory {
     return this.consumer.getPath();
   }
 
+  /**
+   * Get the location of the bit roots folder
+   */
+  get rootComponentsPath() {
+    return this.config.rootComponentsDirectory ?? path.join(this.modulesPath, '.bit_roots');
+  }
+
   /** get the `node_modules` folder of this workspace */
   private get modulesPath() {
     return path.join(this.path, 'node_modules');
@@ -1706,9 +1718,17 @@ the following envs are used in this workspace: ${availableEnvs.join(', ')}`);
   }
 
   async getComponentPackagePath(component: Component) {
-    const inInWs = await this.hasId(component.id);
-    const relativePath = this.dependencyResolver.getRuntimeModulePath(component, inInWs);
-    return path.join(this.path, relativePath);
+    return path.join(this.path, await this._getComponentRelativePath(component));
+  }
+
+  async _getComponentRelativePath(component: Component) {
+    if (this.hasId(component.id)) {
+      return this.dependencyResolver.getRuntimeModulePathInWorkspace(component, {
+        workspacePath: this.path,
+        rootComponentsPath: this.rootComponentsPath,
+      });
+    }
+    return this.dependencyResolver.getRuntimeModulePathInCapsules(component);
   }
 
   // TODO: should we return here the dir as it defined (aka components) or with /{name} prefix (as it used in legacy)

scopes/workspace/workspace/workspace.ts

@@ -1,5 +1,5 @@
 import * as path from 'path';
-import { getRootComponentDir } from '@teambit/bit-roots';
+import { getRootComponentDir } from '@teambit/workspace.root-components';
 import CommandHelper from './e2e-command-helper';
 import ExtensionsHelper from './e2e-extensions-helper';
 import FixtureHelper, { GenerateEnvJsoncOptions } from './e2e-fixtures-helper';
@@ -47,7 +47,7 @@ export default class EnvHelper {
   }
 
   rootCompDir(envName: string) {
-    return getRootComponentDir(this.scopes.localPath, envName);
+    return getRootComponentDir(path.join(this.scopes.localPath, 'node_modules/.bit_roots'), envName);
   }
 
   getTypeScriptSettingsForES5() {