@teambit/workspace 1.0.108 → 1.0.109

package/bit-map.ts

@@ -1,277 +0,0 @@
-import { isEqual, merge } from 'lodash';
-import { ComponentID } from '@teambit/component-id';
-import LegacyBitMap from '@teambit/legacy/dist/consumer/bit-map';
-import { Consumer } from '@teambit/legacy/dist/consumer';
-import { GetBitMapComponentOptions } from '@teambit/legacy/dist/consumer/bit-map/bit-map';
-import ComponentMap from '@teambit/legacy/dist/consumer/bit-map/component-map';
-import { REMOVE_EXTENSION_SPECIAL_SIGN } from '@teambit/legacy/dist/consumer/config';
-import { BitError } from '@teambit/bit-error';
-import { LaneId } from '@teambit/lane-id';
-import EnvsAspect from '@teambit/envs';
-import { getPathStatIfExist } from '@teambit/legacy/dist/utils/fs/last-modified';
-import { PathOsBasedAbsolute } from '@teambit/legacy/dist/utils/path';
-
-export type MergeOptions = {
-  mergeStrategy?: 'theirs' | 'ours' | 'manual';
-};
-/**
- * consider extracting to a new component.
- * (pro: making Workspace aspect smaller. con: it's an implementation details of the workspace)
- */
-export class BitMap {
-  constructor(private legacyBitMap: LegacyBitMap, private consumer: Consumer) {}
-
-  mergeBitmaps(bitmapContent: string, otherBitmapContent: string, opts: MergeOptions = {}): string {
-    return LegacyBitMap.mergeContent(bitmapContent, otherBitmapContent, opts);
-  }
-
-  getPath(): PathOsBasedAbsolute {
-    return this.legacyBitMap.mapPath;
-  }
-
-  /**
-   * adds component config to the .bitmap file.
-   * later, upon `bit tag`, the data is saved in the scope.
-   * returns a boolean indicating whether a change has been made.
-   */
-  addComponentConfig(
-    id: ComponentID,
-    aspectId: string,
-    config: Record<string, any> = {},
-    shouldMergeConfig = false
-  ): boolean {
-    if (!aspectId || typeof aspectId !== 'string') throw new Error(`expect aspectId to be string, got ${aspectId}`);
-    const bitMapEntry = this.getBitmapEntry(id, { ignoreVersion: true });
-    const currentConfig = (bitMapEntry.config ||= {})[aspectId];
-    if (isEqual(currentConfig, config)) {
-      return false; // no changes
-    }
-    const getNewConfig = () => {
-      if (!config) return null;
-      if (!shouldMergeConfig) return config;
-      // should merge
-      if (!currentConfig) return config;
-      if (currentConfig === '-') return config;
-      // lodash merge performs a deep merge. (the native concatenation don't)
-      return merge(currentConfig, config);
-    };
-    const newConfig = getNewConfig();
-    if (newConfig) {
-      bitMapEntry.config[aspectId] = newConfig;
-    } else {
-      delete bitMapEntry.config[aspectId];
-    }
-    this.legacyBitMap.markAsChanged();
-
-    return true; // changes have been made
-  }
-
-  updateDefaultScope(oldScope: string, newScope: string) {
-    const changedId: ComponentID[] = [];
-    this.legacyBitMap.components.forEach((componentMap) => {
-      // only new components (not snapped/tagged) can be changed
-      if (componentMap.defaultScope === oldScope && !componentMap.id.hasVersion()) {
-        componentMap.defaultScope = newScope;
-        changedId.push(componentMap.id);
-      }
-    });
-    if (changedId.length) {
-      this.legacyBitMap.markAsChanged();
-    }
-    return changedId;
-  }
-
-  markAsChanged() {
-    this.legacyBitMap.markAsChanged();
-  }
-
-  removeComponentConfig(id: ComponentID, aspectId: string, markWithMinusIfNotExist: boolean): boolean {
-    if (!aspectId || typeof aspectId !== 'string') throw new Error(`expect aspectId to be string, got ${aspectId}`);
-    const bitMapEntry = this.getBitmapEntry(id, { ignoreVersion: true });
-    const currentConfig = (bitMapEntry.config ||= {})[aspectId];
-    if (currentConfig) {
-      delete bitMapEntry.config[aspectId];
-    } else {
-      if (!markWithMinusIfNotExist) {
-        return false; // no changes
-      }
-      bitMapEntry.config[aspectId] = REMOVE_EXTENSION_SPECIAL_SIGN;
-    }
-
-    this.legacyBitMap.markAsChanged();
-
-    return true; // changes have been made
-  }
-
-  removeEntireConfig(id: ComponentID): boolean {
-    const bitMapEntry = this.getBitmapEntry(id, { ignoreVersion: true });
-    if (!bitMapEntry.config) return false;
-    delete bitMapEntry.config;
-    this.legacyBitMap.markAsChanged();
-    return true;
-  }
-
-  setEntireConfig(id: ComponentID, config: Record<string, any>) {
-    const bitMapEntry = this.getBitmapEntry(id, { ignoreVersion: true });
-    bitMapEntry.config = config;
-    this.legacyBitMap.markAsChanged();
-  }
-
-  removeDefaultScope(id: ComponentID) {
-    const bitMapEntry = this.getBitmapEntry(id, { ignoreVersion: true });
-    if (bitMapEntry.defaultScope) {
-      delete bitMapEntry.defaultScope;
-      this.legacyBitMap.markAsChanged();
-    }
-  }
-
-  setDefaultScope(id: ComponentID, defaultScope: string) {
-    const bitMapEntry = this.getBitmapEntry(id, { ignoreVersion: true });
-    bitMapEntry.defaultScope = defaultScope;
-    bitMapEntry.id = bitMapEntry.id.changeDefaultScope(defaultScope);
-    this.legacyBitMap.markAsChanged();
-  }
-
-  /**
-   * write .bitmap object to the filesystem
-   * optionally pass a reason for the change to be saved in the local scope `bitmap-history-metadata.txt` file.
-   */
-  async write(reasonForChange?: string) {
-    await this.consumer.writeBitMap(reasonForChange);
-  }
-
-  /**
-   * get the data saved in the .bitmap file for this component-id.
-   * throws if not found
-   * @see this.getBitmapEntryIfExist
-   */
-  getBitmapEntry(id: ComponentID, { ignoreVersion }: GetBitMapComponentOptions = {}): ComponentMap {
-    return this.legacyBitMap.getComponent(id, { ignoreVersion });
-  }
-
-  getBitmapEntryIfExist(id: ComponentID, { ignoreVersion }: GetBitMapComponentOptions = {}): ComponentMap | undefined {
-    return this.legacyBitMap.getComponentIfExist(id, { ignoreVersion });
-  }
-
-  getAspectIdFromConfig(
-    componentId: ComponentID,
-    aspectId: ComponentID,
-    ignoreAspectVersion = false
-  ): string | undefined {
-    const bitMapEntry = this.getBitmapEntry(componentId);
-    const config = bitMapEntry.config;
-    if (!config) {
-      return undefined;
-    }
-    if (config[aspectId.toString()]) {
-      return aspectId.toString();
-    }
-    if (!ignoreAspectVersion) {
-      return undefined;
-    }
-    const allVersions = Object.keys(config).filter((id) => id.startsWith(`${aspectId.toStringWithoutVersion()}@`));
-    if (allVersions.length > 1) {
-      throw new BitError(
-        `error: the same aspect ${
-          aspectId.toStringWithoutVersion
-        } configured multiple times for "${componentId.toString()}"\n${allVersions.join('\n')}`
-      );
-    }
-    return allVersions.length === 1 ? allVersions[0] : undefined;
-  }
-
-  /**
-   * components that were not tagged yet are safe to rename them from the .bitmap file.
-   */
-  renameNewComponent(sourceId: ComponentID, targetId: ComponentID) {
-    const bitMapEntry = this.getBitmapEntry(sourceId);
-    if (bitMapEntry.id.hasVersion()) {
-      throw new Error(`unable to rename tagged or exported component: ${bitMapEntry.id.toString()}`);
-    }
-    if (sourceId.isEqual(targetId)) {
-      throw new Error(`source-id and target-id are equal: "${sourceId.toString()}"`);
-    }
-    if (sourceId.fullName !== targetId.fullName) {
-      this.legacyBitMap.removeComponent(bitMapEntry.id);
-      bitMapEntry.id = targetId;
-      this.legacyBitMap.setComponent(bitMapEntry.id, bitMapEntry);
-    }
-    if (sourceId.scope !== targetId.scope) {
-      this.setDefaultScope(sourceId, targetId.scope);
-    }
-  }
-
-  /**
-   * helpful when reaming an aspect and this aspect is used in the config of other components.
-   */
-  renameAspectInConfig(sourceId: ComponentID, targetId: ComponentID) {
-    this.legacyBitMap.components.forEach((componentMap) => {
-      const config = componentMap.config;
-      if (!config) return;
-      Object.keys(config).forEach((aspectId) => {
-        if (aspectId === sourceId.toString()) {
-          config[targetId.toString()] = config[aspectId];
-          delete config[aspectId];
-          this.markAsChanged();
-        }
-        if (aspectId === EnvsAspect.id) {
-          const envConfig = config[aspectId];
-          if (envConfig !== REMOVE_EXTENSION_SPECIAL_SIGN && envConfig.env === sourceId.toString()) {
-            envConfig.env = targetId.toString();
-            this.markAsChanged();
-          }
-        }
-      });
-      componentMap.config = config;
-    });
-  }
-
-  removeComponent(id: ComponentID) {
-    this.legacyBitMap.removeComponent(id);
-  }
-
-  /**
-   * this is the lane-id of the recently exported lane. in case of a new lane, which was not exported yet, this will be
-   * empty.
-   */
-  getExportedLaneId(): LaneId | undefined {
-    return this.legacyBitMap.isLaneExported ? this.legacyBitMap.laneId : undefined;
-  }
-
-  makeComponentsAvailableOnMain(ids: ComponentID[]) {
-    ids.forEach((id) => {
-      const componentMap = this.getBitmapEntry(id);
-      componentMap.isAvailableOnCurrentLane = true;
-      delete componentMap.onLanesOnly;
-    });
-    this.legacyBitMap.markAsChanged();
-  }
-
-  /**
-   * whether .bitmap file has changed in-memory
-   */
-  hasChanged(): boolean {
-    return this.legacyBitMap.hasChanged;
-  }
-
-  takeSnapshot(): ComponentMap[] {
-    return this.legacyBitMap.components.map((comp) => comp.clone());
-  }
-
-  restoreFromSnapshot(componentMaps: ComponentMap[]) {
-    this.legacyBitMap.components = componentMaps;
-    this.legacyBitMap._invalidateCache();
-  }
-
-  /**
-   * .bitmap file could be changed by other sources (e.g. manually or by "git pull") not only by bit.
-   * this method returns the timestamp when the .bitmap has changed through bit. (e.g. as part of snap/tag/export/merge
-   * process)
-   */
-  async getLastModifiedBitmapThroughBit(): Promise<number | undefined> {
-    const bitmapHistoryDir = this.consumer.getBitmapHistoryDir();
-    const stat = await getPathStatIfExist(bitmapHistoryDir);
-    if (!stat) return undefined;
-    return stat.mtimeMs;
-  }
-}

package/build-graph-from-fs.ts

@@ -1,188 +0,0 @@
-import mapSeries from 'p-map-series';
-import { Graph, Node, Edge } from '@teambit/graph.cleargraph';
-import { flatten } from 'lodash';
-import { Consumer } from '@teambit/legacy/dist/consumer';
-import { Component, ComponentID } from '@teambit/component';
-import { DependencyResolverMain } from '@teambit/dependency-resolver';
-import { ComponentIdList } from '@teambit/component-id';
-import { Lane } from '@teambit/legacy/dist/scope/models';
-import { ComponentNotFound, ScopeNotFound } from '@teambit/legacy/dist/scope/exceptions';
-import { ComponentNotFound as ComponentNotFoundInScope } from '@teambit/scope';
-import compact from 'lodash.compact';
-import { Logger } from '@teambit/logger';
-import { BitError } from '@teambit/bit-error';
-import { Workspace } from './workspace';
-
-export type ShouldLoadFunc = (id: ComponentID) => Promise<boolean>;
-
-export class GraphFromFsBuilder {
-  private graph = new Graph<Component, string>();
-  private completed: string[] = [];
-  private depth = 1;
-  private consumer: Consumer;
-  private importedIds: string[] = [];
-  private currentLane: Lane | null;
-  constructor(
-    private workspace: Workspace,
-    private logger: Logger,
-    private dependencyResolver: DependencyResolverMain,
-    private ignoreIds: string[] = [],
-    private shouldLoadItsDeps?: ShouldLoadFunc,
-    private shouldThrowOnMissingDep = true
-  ) {
-    this.consumer = this.workspace.consumer;
-  }
-
-  /**
-   * create a graph with all dependencies and flattened dependencies of the given components.
-   * the nodes are components and the edges has a label of the dependency type.
-   *
-   * the way how it is done is iterations by depths. each depth we gather all the dependencies of
-   * that depths, make sure all objects exist and then check their dependencies for the next depth.
-   * once there is no dependency left, we're on the last depth level and the graph is ready.
-   *
-   * for example, imagine the following graph:
-   * A1 -> A2 -> A3
-   * B1 -> B2 -> B3
-   * C1 -> C2 -> C3
-   *
-   * where the buildGraph is given [A1, B1, C1].
-   * first, it saves all these components as nodes in the graph. then, it finds the dependencies of
-   * the next level, in this case they're [A2, B2, C2]. it runs `importMany` in case some objects
-   * are missing. then, it loads them all (some from FS, some from the model) and sets the edges
-   * between the component and the dependencies.
-   * once done, it finds all their dependencies, which are [A3, B3, C3] and repeat the process
-   * above. since there are no more dependencies, the graph is completed.
-   * in this case, the total depth levels are 3.
-   *
-   * even with a huge project, there are not many depth levels. by iterating through depth levels
-   * we keep performance sane as the importMany doesn't run multiple time and therefore the round
-   * trips to the remotes are minimal.
-   *
-   * normally, one importMany of the seeders is enough as importMany knows to fetch all flattened.
-   * however, since this buildGraph is performed on the workspace, a dependency may be new or
-   * modified and as such, we don't know its flattened yet.
-   */
-  async buildGraph(ids: ComponentID[]): Promise<Graph<Component, string>> {
-    this.logger.debug(`GraphFromFsBuilder, buildGraph with ${ids.length} seeders`);
-    const start = Date.now();
-    const components = await this.loadManyComponents(ids);
-    this.currentLane = await this.workspace.consumer.getCurrentLaneObject();
-    await this.processManyComponents(components);
-    this.logger.debug(
-      `GraphFromFsBuilder, buildGraph with ${ids.length} seeders completed (${(Date.now() - start) / 1000} sec)`
-    );
-    return this.graph;
-  }
-
-  private async getAllDepsUnfiltered(component: Component): Promise<ComponentID[]> {
-    const deps = await this.dependencyResolver.getComponentDependencies(component);
-    const depsIds = deps.map((dep) => dep.componentId);
-
-    return depsIds.filter((depId) => !this.ignoreIds.includes(depId.toString()));
-  }
-
-  private async getAllDepsFiltered(component: Component): Promise<ComponentID[]> {
-    const depsWithoutIgnore = await this.getAllDepsUnfiltered(component);
-    const shouldLoadFunc = this.shouldLoadItsDeps;
-    if (!shouldLoadFunc) return depsWithoutIgnore;
-    const deps = await mapSeries(depsWithoutIgnore, async (depId) => {
-      const shouldLoad = await shouldLoadFunc(depId);
-      if (!shouldLoad) this.ignoreIds.push(depId.toString());
-      return shouldLoad ? depId : null;
-    });
-    return compact(deps);
-  }
-
-  private async processManyComponents(components: Component[]) {
-    this.logger.debug(`GraphFromFsBuilder.processManyComponents depth ${this.depth}, ${components.length} components`);
-    this.depth += 1;
-    await this.importObjects(components);
-    const allDependencies = await mapSeries(components, (component) => this.processOneComponent(component));
-    const allDependenciesFlattened = flatten(allDependencies);
-    if (allDependenciesFlattened.length) await this.processManyComponents(allDependenciesFlattened);
-  }
-
-  /**
-   * only for components from the workspace that can be modified to add/remove dependencies, we need to make sure that
-   * all their dependencies are imported.
-   * remember that `importMany` fetches all flattened dependencies. once a component from scope is imported, we know
-   * that all its flattened dependencies are there. no need to call importMany again for them.
-   */
-  private async importObjects(components: Component[]) {
-    const workspaceIds = await this.workspace.listIds();
-    const compOnWorkspaceOnly = components.filter((comp) => workspaceIds.find((id) => id.isEqual(comp.id)));
-    const allDeps = (await Promise.all(compOnWorkspaceOnly.map((c) => this.getAllDepsUnfiltered(c)))).flat();
-    const allDepsNotImported = allDeps.filter((d) => !this.importedIds.includes(d.toString()));
-    const exportedDeps = allDepsNotImported.map((id) => id).filter((dep) => this.workspace.isExported(dep));
-    const scopeComponentsImporter = this.consumer.scope.scopeImporter;
-    await scopeComponentsImporter.importMany({
-      ids: ComponentIdList.uniqFromArray(exportedDeps),
-      preferDependencyGraph: false,
-      throwForDependencyNotFound: this.shouldThrowOnMissingDep,
-      throwForSeederNotFound: this.shouldThrowOnMissingDep,
-      reFetchUnBuiltVersion: false,
-      lane: this.currentLane || undefined,
-      reason: 'for building a graph from the workspace',
-    });
-    allDepsNotImported.map((id) => this.importedIds.push(id.toString()));
-  }
-
-  private async processOneComponent(component: Component) {
-    const idStr = component.id.toString();
-    if (this.completed.includes(idStr)) return [];
-    const allIds = await this.getAllDepsFiltered(component);
-
-    const allDependenciesComps = await this.loadManyComponents(allIds, idStr);
-    const deps = await this.dependencyResolver.getComponentDependencies(component);
-    deps.forEach((dep) => {
-      const depId = dep.componentId;
-      if (this.ignoreIds.includes(depId.toString())) return;
-      if (!this.graph.hasNode(depId.toString())) {
-        if (this.shouldThrowOnMissingDep) {
-          throw new Error(`buildOneComponent: missing node of ${depId.toString()}`);
-        }
-        this.logger.warn(`ignoring missing ${depId.toString()}`);
-        return;
-      }
-      this.graph.setEdge(new Edge(idStr, depId.toString(), dep.lifecycle));
-    });
-
-    this.completed.push(idStr);
-    return allDependenciesComps;
-  }
-
-  private async loadManyComponents(componentsIds: ComponentID[], dependenciesOf?: string): Promise<Component[]> {
-    const components = await mapSeries(componentsIds, async (comp) => {
-      const idStr = comp.toString();
-      const fromGraph = this.graph.node(idStr)?.attr;
-      if (fromGraph) return fromGraph;
-      try {
-        const component = await this.workspace.get(comp);
-        this.graph.setNode(new Node(idStr, component));
-        return component;
-      } catch (err: any) {
-        if (
-          err instanceof ComponentNotFound ||
-          err instanceof ComponentNotFoundInScope ||
-          err instanceof ScopeNotFound
-        ) {
-          if (dependenciesOf && !this.shouldThrowOnMissingDep) {
-            this.logger.warn(
-              `component ${idStr}, dependency of ${dependenciesOf} was not found. continuing without it`
-            );
-            return null;
-          }
-          throw new BitError(
-            `error: component "${idStr}" was not found.\nthis component is a dependency of "${
-              dependenciesOf || '<none>'
-            }" and is needed as part of the graph generation`
-          );
-        }
-        if (dependenciesOf) this.logger.error(`failed loading dependencies of ${dependenciesOf}`);
-        throw err;
-      }
-    });
-    return compact(components);
-  }
-}

package/build-graph-ids-from-fs.ts

@@ -1,216 +0,0 @@
-import mapSeries from 'p-map-series';
-import { Graph, Node, Edge } from '@teambit/graph.cleargraph';
-import { flatten, partition } from 'lodash';
-import { Consumer } from '@teambit/legacy/dist/consumer';
-import { Component, ComponentID } from '@teambit/component';
-import ConsumerComponent from '@teambit/legacy/dist/consumer/component';
-import { ComponentIdList } from '@teambit/component-id';
-import { ComponentDependency, DependencyResolverMain } from '@teambit/dependency-resolver';
-import { CompIdGraph, DepEdgeType } from '@teambit/graph';
-import { ComponentNotFound, ScopeNotFound } from '@teambit/legacy/dist/scope/exceptions';
-import { ComponentNotFound as ComponentNotFoundInScope } from '@teambit/scope';
-import compact from 'lodash.compact';
-import { Logger } from '@teambit/logger';
-import { BitError } from '@teambit/bit-error';
-import { Workspace } from './workspace';
-
-export function lifecycleToDepType(compDep: ComponentDependency): DepEdgeType {
-  if (compDep.isExtension) return 'ext';
-  switch (compDep.lifecycle) {
-    case 'dev':
-      return 'dev';
-    case 'runtime':
-      return 'prod';
-    default:
-      throw new Error(`lifecycle ${compDep.lifecycle} is not support`);
-  }
-}
-
-export class GraphIdsFromFsBuilder {
-  private graph = new Graph<ComponentID, DepEdgeType>();
-  private completed: string[] = [];
-  private depth = 1;
-  private consumer: Consumer;
-  private loadedComponents: { [idStr: string]: Component } = {};
-  private importedIds: string[] = [];
-  private shouldThrowOnInvalidDeps = true; // for now it has the same value as shouldThrowOnMissingDep. change if needed
-  constructor(
-    private workspace: Workspace,
-    private logger: Logger,
-    private dependencyResolver: DependencyResolverMain,
-    private shouldThrowOnMissingDep = true
-  ) {
-    this.consumer = this.workspace.consumer;
-    this.shouldThrowOnInvalidDeps = this.shouldThrowOnMissingDep;
-  }
-
-  /**
-   * create a graph with all dependencies and flattened dependencies of the given components.
-   * the nodes are component-ids and the edges has a label of the dependency type.
-   * to get some info about this the graph build take a look into build-graph-from-fs.buildGraph() docs.
-   */
-  async buildGraph(ids: ComponentID[]): Promise<Graph<ComponentID, DepEdgeType>> {
-    this.logger.debug(`GraphIdsFromFsBuilder, buildGraph with ${ids.length} seeders`);
-    const start = Date.now();
-    const components = await this.loadManyComponents(ids);
-    await this.processManyComponents(components);
-    this.logger.debug(
-      `GraphIdsFromFsBuilder, buildGraph with ${ids.length} seeders completed (${(Date.now() - start) / 1000} sec)`
-    );
-    return this.graph;
-  }
-
-  private async processManyComponents(components: Component[]) {
-    this.logger.debug(
-      `GraphIdsFromFsBuilder.processManyComponents depth ${this.depth}, ${components.length} components`
-    );
-    this.depth += 1;
-    await this.importObjects(components);
-    const allDependencies = await mapSeries(components, (component) => this.processOneComponent(component));
-    const allDependenciesFlattened = flatten(allDependencies);
-    if (allDependenciesFlattened.length) await this.processManyComponents(allDependenciesFlattened);
-  }
-
-  /**
-   * only for components from the workspace that can be modified to add/remove dependencies, we need to make sure that
-   * all their dependencies are imported.
-   * once a component from scope is imported, we know that either we have its dependency graph or all flattened deps
-   */
-  private async importObjects(components: Component[]) {
-    const workspaceIds = await this.workspace.listIds();
-    const compOnWorkspaceOnly = components.filter((comp) => workspaceIds.find((id) => id.isEqual(comp.id)));
-    const notImported = compOnWorkspaceOnly.map((c) => c.id).filter((id) => !this.importedIds.includes(id.toString()));
-    const exportedDeps = notImported.filter((dep) => this.workspace.isExported(dep));
-    const scopeComponentsImporter = this.consumer.scope.scopeImporter;
-    await scopeComponentsImporter.importMany({
-      ids: ComponentIdList.uniqFromArray(exportedDeps),
-      throwForDependencyNotFound: this.shouldThrowOnMissingDep,
-      throwForSeederNotFound: this.shouldThrowOnMissingDep,
-      reFetchUnBuiltVersion: false,
-      lane: (await this.workspace.getCurrentLaneObject()) || undefined,
-      reason: 'for building graph-ids from the workspace',
-    });
-    notImported.map((id) => this.importedIds.push(id.toString()));
-  }
-
-  private async processOneComponent(component: Component) {
-    const idStr = component.id.toString();
-    if (this.completed.includes(idStr)) return [];
-    const graphFromScope = await this.workspace.getSavedGraphOfComponentIfExist(component);
-    if (graphFromScope?.edges.length) {
-      const isOnWorkspace = await this.workspace.hasId(component.id);
-      if (isOnWorkspace) {
-        const allDependenciesComps = await this.processCompFromWorkspaceWithGraph(graphFromScope, component);
-        this.completed.push(idStr);
-        return allDependenciesComps;
-      }
-      this.graph.merge([graphFromScope]);
-      this.completed.push(idStr);
-      return [];
-    }
-
-    const deps = await this.dependencyResolver.getComponentDependencies(component);
-    const allDepsIds = deps.map((d) => d.componentId);
-    const allDependenciesComps = await this.loadManyComponents(allDepsIds, idStr);
-
-    deps.forEach((dep) => this.addDepEdge(idStr, dep));
-    this.completed.push(idStr);
-
-    return allDependenciesComps;
-  }
-
-  /**
-   * this is tricky.
-   * the component is in the workspace so it can be modified. dependencies can be added/removed/updated/downgraded.
-   * we have the graph-dependencies from the last snap, so we prefer to use it whenever possible for performance reasons.
-   * if we can't use it, we have to recursively load dependencies components and get the data from there.
-   * to maximize the performance, we iterate the direct dependencies, if we find a dep with the same id in the graph,
-   * and that id is not in the workspace then ask the graph for all its successors. otherwise, if it's not there, or
-   * it's there but it's also in the workspace (which therefore can be modified), we recursively load the dep components
-   * and get its dependencies.
-   */
-  private async processCompFromWorkspaceWithGraph(
-    graphFromScope: CompIdGraph,
-    component: Component
-  ): Promise<Component[]> {
-    const deps = await this.dependencyResolver.getComponentDependencies(component);
-    const workspaceIds = await this.workspace.listIds();
-    const [depsInScopeGraph, depsNotInScopeGraph] = partition(
-      deps,
-      (dep) =>
-        graphFromScope.hasNode(dep.componentId.toString()) && !workspaceIds.find((id) => id.isEqual(dep.componentId))
-    );
-
-    const depsInScopeGraphIds = depsInScopeGraph.map((dep) => dep.componentId.toString());
-    const depsInScopeGraphIdsNotCompleted = depsInScopeGraphIds.filter((id) => !this.completed.includes(id));
-    if (depsInScopeGraphIdsNotCompleted.length) {
-      const subGraphs = graphFromScope.successorsSubgraph(depsInScopeGraphIdsNotCompleted);
-      this.graph.merge([subGraphs]);
-      this.completed.push(...depsInScopeGraphIdsNotCompleted);
-    }
-
-    const allDepsIds = depsNotInScopeGraph.map((d) => d.componentId);
-    const idStr = component.id.toString();
-    const allDependenciesComps = await this.loadManyComponents(allDepsIds, idStr);
-    deps.forEach((dep) => this.addDepEdge(idStr, dep));
-    return allDependenciesComps;
-  }
-
-  private addDepEdge(idStr: string, dep: ComponentDependency) {
-    const depId = dep.componentId;
-    if (!this.graph.hasNode(depId.toString())) {
-      if (this.shouldThrowOnMissingDep) {
-        throw new Error(`buildOneComponent: missing node of ${depId.toString()}`);
-      }
-      this.logger.warn(`ignoring missing ${depId.toString()}`);
-      return;
-    }
-    this.graph.setEdge(new Edge(idStr, depId.toString(), lifecycleToDepType(dep)));
-  }
-
-  private async loadManyComponents(componentsIds: ComponentID[], dependenciesOf?: string): Promise<Component[]> {
-    const components = await mapSeries(componentsIds, async (comp) => {
-      const idStr = comp.toString();
-      const fromCache = this.loadedComponents[idStr];
-      if (fromCache) return fromCache;
-      try {
-        const component = await this.workspace.get(comp);
-        this.loadedComponents[idStr] = component;
-        this.graph.setNode(new Node(idStr, component.id));
-        return component;
-      } catch (err: any) {
-        if (
-          err instanceof ComponentNotFound ||
-          err instanceof ComponentNotFoundInScope ||
-          err instanceof ScopeNotFound
-        ) {
-          if (dependenciesOf && !this.shouldThrowOnMissingDep) {
-            this.logger.warn(
-              `component ${idStr}, dependency of ${dependenciesOf} was not found. continuing without it`
-            );
-            return null;
-          }
-          throw new BitError(
-            `error: component "${idStr}" was not found.\nthis component is a dependency of "${
-              dependenciesOf || '<none>'
-            }" and is needed as part of the graph generation`
-          );
-        }
-        if (ConsumerComponent.isComponentInvalidByErrorType(err)) {
-          if (dependenciesOf && !this.shouldThrowOnInvalidDeps) {
-            this.logger.warn(`component ${idStr}, dependency of ${dependenciesOf} is invalid. continuing without it`);
-            return null;
-          }
-          throw new BitError(
-            `error: component "${idStr}" is invalid (${err.message}).\nthis component is a dependency of "${
-              dependenciesOf || '<none>'
-            }" and is needed as part of the graph generation`
-          );
-        }
-        if (dependenciesOf) this.logger.error(`failed loading dependencies of ${dependenciesOf}`);
-        throw err;
-      }
-    });
-    return compact(components);
-  }
-}