@teambit/workspace 0.0.537 → 0.0.545

package/build-graph-from-fs.ts

@@ -0,0 +1,160 @@
+import mapSeries from 'p-map-series';
+import { flatten } from 'lodash';
+import { Consumer } from '@teambit/legacy/dist/consumer';
+import BitIds from '@teambit/legacy/dist/bit-id/bit-ids';
+import Component from '@teambit/legacy/dist/consumer/component/consumer-component';
+import LegacyGraph from '@teambit/legacy/dist/scope/graph/graph';
+import ScopeComponentsImporter from '@teambit/legacy/dist/scope/component-ops/scope-components-importer';
+import compact from 'lodash.compact';
+import { BitId } from '@teambit/legacy-bit-id';
+import { Logger } from '@teambit/logger';
+import { ComponentNotFound } from '@teambit/scope';
+import { BitError } from '@teambit/bit-error';
+import { Workspace } from './workspace';
+
+export type ShouldIgnoreFunc = (bitId: BitId) => Promise<boolean>;
+
+export class GraphFromFsBuilder {
+  private graph = new LegacyGraph();
+  private completed: string[] = [];
+  private depth = 1;
+  private shouldThrowOnMissingDep = true;
+  private consumer: Consumer;
+  constructor(
+    private workspace: Workspace,
+    private logger: Logger,
+    private ignoreIds = new BitIds(),
+    private shouldLoadItsDeps?: ShouldIgnoreFunc
+  ) {
+    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: BitId[]): Promise<LegacyGraph> {
+    this.logger.debug(`GraphFromFsBuilder, buildGraph with ${ids.length} seeders`);
+    const start = Date.now();
+    const components = await this.loadManyComponents(ids, '<none>');
+    await this.processManyComponents(components);
+    this.logger.debug(
+      `GraphFromFsBuilder, buildGraph with ${ids.length} seeders completed (${(Date.now() - start) / 1000} sec)`
+    );
+    return this.graph;
+  }
+
+  private getAllDepsUnfiltered(component: Component) {
+    return component.getAllDependenciesIds().difference(this.ignoreIds);
+  }
+
+  private async getAllDepsFiltered(component: Component): Promise<BitIds> {
+    const depsWithoutIgnore = 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);
+      return shouldLoad ? depId : null;
+    });
+    return BitIds.fromArray(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);
+  }
+
+  private async importObjects(components: Component[]) {
+    const allDeps = components.map((c) => this.getAllDepsUnfiltered(c)).flat();
+    const allDepsWithScope = allDeps.filter((dep) => dep.hasScope());
+    const scopeComponentsImporter = new ScopeComponentsImporter(this.consumer.scope);
+    await scopeComponentsImporter.importMany(
+      BitIds.uniqFromArray(allDepsWithScope),
+      undefined,
+      this.shouldThrowOnMissingDep
+    );
+  }
+
+  private async processOneComponent(component: Component) {
+    const idStr = component.id.toString();
+    if (this.completed.includes(idStr)) return [];
+    const allIds = await this.getAllDepsFiltered(component);
+
+    const allDependencies = await this.loadManyComponents(allIds, idStr);
+    Object.entries(component.depsIdsGroupedByType).forEach(([depType, depsIds]) => {
+      depsIds.forEach((depId) => {
+        if (this.ignoreIds.has(depId)) return;
+        if (!this.graph.hasNode(depId.toString())) {
+          throw new Error(`buildOneComponent: missing node of ${depId.toString()}`);
+        }
+        this.graph.setEdge(idStr, depId.toString(), depType);
+      });
+    });
+    this.completed.push(idStr);
+    return allDependencies;
+  }
+
+  private async loadManyComponents(componentsIds: BitId[], dependenciesOf: string): Promise<Component[]> {
+    const components = await mapSeries(componentsIds, async (comp: BitId) => {
+      const idStr = comp.toString();
+      const fromGraph = this.graph.node(idStr);
+      if (fromGraph) return fromGraph;
+      try {
+        const component = await this.loadComponent(comp);
+        this.graph.setNode(idStr, component);
+        return component;
+      } catch (err: any) {
+        if (err instanceof ComponentNotFound) {
+          throw new BitError(
+            `error: component "${idStr}" was not found.\nthis component is a dependency of "${dependenciesOf}" and is needed as part of the graph generation`
+          );
+        }
+        this.logger.error(`failed loading dependencies of ${dependenciesOf}`);
+        throw err;
+      }
+    });
+    return components;
+  }
+  private async loadComponent(componentId: BitId): Promise<Component> {
+    const componentMap = this.consumer.bitMap.getComponentIfExist(componentId);
+    const isOnWorkspace = Boolean(componentMap);
+    if (isOnWorkspace) {
+      return this.consumer.loadComponentForCapsule(componentId);
+    }
+    // a dependency might have been installed as a package in the workspace, and as such doesn't
+    // have a componentMap.
+    const componentFromModel = await this.consumer.loadComponentFromModel(componentId);
+    return componentFromModel.clone();
+  }
+}

package/dist/build-graph-from-fs.d.ts

@@ -0,0 +1,26 @@
+import BitIds from '@teambit/legacy/dist/bit-id/bit-ids';
+import LegacyGraph from '@teambit/legacy/dist/scope/graph/graph';
+import { BitId } from '@teambit/legacy-bit-id';
+import { Logger } from '@teambit/logger';
+import { Workspace } from './workspace';
+export declare type ShouldIgnoreFunc = (bitId: BitId) => Promise<boolean>;
+export declare class GraphFromFsBuilder {
+    private workspace;
+    private logger;
+    private ignoreIds;
+    private shouldLoadItsDeps?;
+    private graph;
+    private completed;
+    private depth;
+    private shouldThrowOnMissingDep;
+    private consumer;
+    constructor(workspace: Workspace, logger: Logger, ignoreIds?: BitIds, shouldLoadItsDeps?: ShouldIgnoreFunc | undefined);
+    buildGraph(ids: BitId[]): Promise<LegacyGraph>;
+    private getAllDepsUnfiltered;
+    private getAllDepsFiltered;
+    private processManyComponents;
+    private importObjects;
+    private processOneComponent;
+    private loadManyComponents;
+    private loadComponent;
+}

package/dist/build-graph-from-fs.js

@@ -0,0 +1,254 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+require("core-js/modules/es.array.flat.js");
+
+require("core-js/modules/es.array.iterator.js");
+
+require("core-js/modules/es.array.unscopables.flat.js");
+
+require("core-js/modules/es.promise.js");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.GraphFromFsBuilder = void 0;
+
+function _defineProperty2() {
+  const data = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+
+  _defineProperty2 = function () {
+    return data;
+  };
+
+  return data;
+}
+
+function _pMapSeries() {
+  const data = _interopRequireDefault(require("p-map-series"));
+
+  _pMapSeries = function () {
+    return data;
+  };
+
+  return data;
+}
+
+function _lodash() {
+  const data = require("lodash");
+
+  _lodash = function () {
+    return data;
+  };
+
+  return data;
+}
+
+function _bitIds() {
+  const data = _interopRequireDefault(require("@teambit/legacy/dist/bit-id/bit-ids"));
+
+  _bitIds = function () {
+    return data;
+  };
+
+  return data;
+}
+
+function _graph() {
+  const data = _interopRequireDefault(require("@teambit/legacy/dist/scope/graph/graph"));
+
+  _graph = function () {
+    return data;
+  };
+
+  return data;
+}
+
+function _scopeComponentsImporter() {
+  const data = _interopRequireDefault(require("@teambit/legacy/dist/scope/component-ops/scope-components-importer"));
+
+  _scopeComponentsImporter = function () {
+    return data;
+  };
+
+  return data;
+}
+
+function _lodash2() {
+  const data = _interopRequireDefault(require("lodash.compact"));
+
+  _lodash2 = function () {
+    return data;
+  };
+
+  return data;
+}
+
+function _scope() {
+  const data = require("@teambit/scope");
+
+  _scope = function () {
+    return data;
+  };
+
+  return data;
+}
+
+function _bitError() {
+  const data = require("@teambit/bit-error");
+
+  _bitError = function () {
+    return data;
+  };
+
+  return data;
+}
+
+class GraphFromFsBuilder {
+  constructor(workspace, logger, ignoreIds = new (_bitIds().default)(), shouldLoadItsDeps) {
+    this.workspace = workspace;
+    this.logger = logger;
+    this.ignoreIds = ignoreIds;
+    this.shouldLoadItsDeps = shouldLoadItsDeps;
+    (0, _defineProperty2().default)(this, "graph", new (_graph().default)());
+    (0, _defineProperty2().default)(this, "completed", []);
+    (0, _defineProperty2().default)(this, "depth", 1);
+    (0, _defineProperty2().default)(this, "shouldThrowOnMissingDep", true);
+    (0, _defineProperty2().default)(this, "consumer", void 0);
+    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) {
+    this.logger.debug(`GraphFromFsBuilder, buildGraph with ${ids.length} seeders`);
+    const start = Date.now();
+    const components = await this.loadManyComponents(ids, '<none>');
+    await this.processManyComponents(components);
+    this.logger.debug(`GraphFromFsBuilder, buildGraph with ${ids.length} seeders completed (${(Date.now() - start) / 1000} sec)`);
+    return this.graph;
+  }
+
+  getAllDepsUnfiltered(component) {
+    return component.getAllDependenciesIds().difference(this.ignoreIds);
+  }
+
+  async getAllDepsFiltered(component) {
+    const depsWithoutIgnore = this.getAllDepsUnfiltered(component);
+    const shouldLoadFunc = this.shouldLoadItsDeps;
+    if (!shouldLoadFunc) return depsWithoutIgnore;
+    const deps = await (0, _pMapSeries().default)(depsWithoutIgnore, async depId => {
+      const shouldLoad = await shouldLoadFunc(depId);
+      if (!shouldLoad) this.ignoreIds.push(depId);
+      return shouldLoad ? depId : null;
+    });
+    return _bitIds().default.fromArray((0, _lodash2().default)(deps));
+  }
+
+  async processManyComponents(components) {
+    this.logger.debug(`GraphFromFsBuilder.processManyComponents depth ${this.depth}, ${components.length} components`);
+    this.depth += 1;
+    await this.importObjects(components);
+    const allDependencies = await (0, _pMapSeries().default)(components, component => this.processOneComponent(component));
+    const allDependenciesFlattened = (0, _lodash().flatten)(allDependencies);
+    if (allDependenciesFlattened.length) await this.processManyComponents(allDependenciesFlattened);
+  }
+
+  async importObjects(components) {
+    const allDeps = components.map(c => this.getAllDepsUnfiltered(c)).flat();
+    const allDepsWithScope = allDeps.filter(dep => dep.hasScope());
+    const scopeComponentsImporter = new (_scopeComponentsImporter().default)(this.consumer.scope);
+    await scopeComponentsImporter.importMany(_bitIds().default.uniqFromArray(allDepsWithScope), undefined, this.shouldThrowOnMissingDep);
+  }
+
+  async processOneComponent(component) {
+    const idStr = component.id.toString();
+    if (this.completed.includes(idStr)) return [];
+    const allIds = await this.getAllDepsFiltered(component);
+    const allDependencies = await this.loadManyComponents(allIds, idStr);
+    Object.entries(component.depsIdsGroupedByType).forEach(([depType, depsIds]) => {
+      depsIds.forEach(depId => {
+        if (this.ignoreIds.has(depId)) return;
+
+        if (!this.graph.hasNode(depId.toString())) {
+          throw new Error(`buildOneComponent: missing node of ${depId.toString()}`);
+        }
+
+        this.graph.setEdge(idStr, depId.toString(), depType);
+      });
+    });
+    this.completed.push(idStr);
+    return allDependencies;
+  }
+
+  async loadManyComponents(componentsIds, dependenciesOf) {
+    const components = await (0, _pMapSeries().default)(componentsIds, async comp => {
+      const idStr = comp.toString();
+      const fromGraph = this.graph.node(idStr);
+      if (fromGraph) return fromGraph;
+
+      try {
+        const component = await this.loadComponent(comp);
+        this.graph.setNode(idStr, component);
+        return component;
+      } catch (err) {
+        if (err instanceof _scope().ComponentNotFound) {
+          throw new (_bitError().BitError)(`error: component "${idStr}" was not found.\nthis component is a dependency of "${dependenciesOf}" and is needed as part of the graph generation`);
+        }
+
+        this.logger.error(`failed loading dependencies of ${dependenciesOf}`);
+        throw err;
+      }
+    });
+    return components;
+  }
+
+  async loadComponent(componentId) {
+    const componentMap = this.consumer.bitMap.getComponentIfExist(componentId);
+    const isOnWorkspace = Boolean(componentMap);
+
+    if (isOnWorkspace) {
+      return this.consumer.loadComponentForCapsule(componentId);
+    } // a dependency might have been installed as a package in the workspace, and as such doesn't
+    // have a componentMap.
+
+
+    const componentFromModel = await this.consumer.loadComponentFromModel(componentId);
+    return componentFromModel.clone();
+  }
+
+}
+
+exports.GraphFromFsBuilder = GraphFromFsBuilder;
+
+//# sourceMappingURL=build-graph-from-fs.js.map

package/dist/build-graph-from-fs.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["build-graph-from-fs.ts"],"names":["GraphFromFsBuilder","constructor","workspace","logger","ignoreIds","BitIds","shouldLoadItsDeps","LegacyGraph","consumer","buildGraph","ids","debug","length","start","Date","now","components","loadManyComponents","processManyComponents","graph","getAllDepsUnfiltered","component","getAllDependenciesIds","difference","getAllDepsFiltered","depsWithoutIgnore","shouldLoadFunc","deps","depId","shouldLoad","push","fromArray","depth","importObjects","allDependencies","processOneComponent","allDependenciesFlattened","allDeps","map","c","flat","allDepsWithScope","filter","dep","hasScope","scopeComponentsImporter","ScopeComponentsImporter","scope","importMany","uniqFromArray","undefined","shouldThrowOnMissingDep","idStr","id","toString","completed","includes","allIds","Object","entries","depsIdsGroupedByType","forEach","depType","depsIds","has","hasNode","Error","setEdge","componentsIds","dependenciesOf","comp","fromGraph","node","loadComponent","setNode","err","ComponentNotFound","BitError","error","componentId","componentMap","bitMap","getComponentIfExist","isOnWorkspace","Boolean","loadComponentForCapsule","componentFromModel","loadComponentFromModel","clone"],"mappings":"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","sourcesContent":["import mapSeries from 'p-map-series';\nimport { flatten } from 'lodash';\nimport { Consumer } from '@teambit/legacy/dist/consumer';\nimport BitIds from '@teambit/legacy/dist/bit-id/bit-ids';\nimport Component from '@teambit/legacy/dist/consumer/component/consumer-component';\nimport LegacyGraph from '@teambit/legacy/dist/scope/graph/graph';\nimport ScopeComponentsImporter from '@teambit/legacy/dist/scope/component-ops/scope-components-importer';\nimport compact from 'lodash.compact';\nimport { BitId } from '@teambit/legacy-bit-id';\nimport { Logger } from '@teambit/logger';\nimport { ComponentNotFound } from '@teambit/scope';\nimport { BitError } from '@teambit/bit-error';\nimport { Workspace } from './workspace';\n\nexport type ShouldIgnoreFunc = (bitId: BitId) => Promise<boolean>;\n\nexport class GraphFromFsBuilder {\n  private graph = new LegacyGraph();\n  private completed: string[] = [];\n  private depth = 1;\n  private shouldThrowOnMissingDep = true;\n  private consumer: Consumer;\n  constructor(\n    private workspace: Workspace,\n    private logger: Logger,\n    private ignoreIds = new BitIds(),\n    private shouldLoadItsDeps?: ShouldIgnoreFunc\n  ) {\n    this.consumer = this.workspace.consumer;\n  }\n\n  /**\n   * create a graph with all dependencies and flattened dependencies of the given components.\n   * the nodes are components and the edges has a label of the dependency type.\n   *\n   * the way how it is done is iterations by depths. each depth we gather all the dependencies of\n   * that depths, make sure all objects exist and then check their dependencies for the next depth.\n   * once there is no dependency left, we're on the last depth level and the graph is ready.\n   *\n   * for example, imagine the following graph:\n   * A1 -> A2 -> A3\n   * B1 -> B2 -> B3\n   * C1 -> C2 -> C3\n   *\n   * where the buildGraph is given [A1, B1, C1].\n   * first, it saves all these components as nodes in the graph. then, it finds the dependencies of\n   * the next level, in this case they're [A2, B2, C2]. it runs `importMany` in case some objects\n   * are missing. then, it loads them all (some from FS, some from the model) and sets the edges\n   * between the component and the dependencies.\n   * once done, it finds all their dependencies, which are [A3, B3, C3] and repeat the process\n   * above. since there are no more dependencies, the graph is completed.\n   * in this case, the total depth levels are 3.\n   *\n   * even with a huge project, there are not many depth levels. by iterating through depth levels\n   * we keep performance sane as the importMany doesn't run multiple time and therefore the round\n   * trips to the remotes are minimal.\n   *\n   * normally, one importMany of the seeders is enough as importMany knows to fetch all flattened.\n   * however, since this buildGraph is performed on the workspace, a dependency may be new or\n   * modified and as such, we don't know its flattened yet.\n   */\n  async buildGraph(ids: BitId[]): Promise<LegacyGraph> {\n    this.logger.debug(`GraphFromFsBuilder, buildGraph with ${ids.length} seeders`);\n    const start = Date.now();\n    const components = await this.loadManyComponents(ids, '<none>');\n    await this.processManyComponents(components);\n    this.logger.debug(\n      `GraphFromFsBuilder, buildGraph with ${ids.length} seeders completed (${(Date.now() - start) / 1000} sec)`\n    );\n    return this.graph;\n  }\n\n  private getAllDepsUnfiltered(component: Component) {\n    return component.getAllDependenciesIds().difference(this.ignoreIds);\n  }\n\n  private async getAllDepsFiltered(component: Component): Promise<BitIds> {\n    const depsWithoutIgnore = this.getAllDepsUnfiltered(component);\n    const shouldLoadFunc = this.shouldLoadItsDeps;\n    if (!shouldLoadFunc) return depsWithoutIgnore;\n    const deps = await mapSeries(depsWithoutIgnore, async (depId) => {\n      const shouldLoad = await shouldLoadFunc(depId);\n      if (!shouldLoad) this.ignoreIds.push(depId);\n      return shouldLoad ? depId : null;\n    });\n    return BitIds.fromArray(compact(deps));\n  }\n\n  private async processManyComponents(components: Component[]) {\n    this.logger.debug(`GraphFromFsBuilder.processManyComponents depth ${this.depth}, ${components.length} components`);\n    this.depth += 1;\n    await this.importObjects(components);\n    const allDependencies = await mapSeries(components, (component) => this.processOneComponent(component));\n    const allDependenciesFlattened = flatten(allDependencies);\n    if (allDependenciesFlattened.length) await this.processManyComponents(allDependenciesFlattened);\n  }\n\n  private async importObjects(components: Component[]) {\n    const allDeps = components.map((c) => this.getAllDepsUnfiltered(c)).flat();\n    const allDepsWithScope = allDeps.filter((dep) => dep.hasScope());\n    const scopeComponentsImporter = new ScopeComponentsImporter(this.consumer.scope);\n    await scopeComponentsImporter.importMany(\n      BitIds.uniqFromArray(allDepsWithScope),\n      undefined,\n      this.shouldThrowOnMissingDep\n    );\n  }\n\n  private async processOneComponent(component: Component) {\n    const idStr = component.id.toString();\n    if (this.completed.includes(idStr)) return [];\n    const allIds = await this.getAllDepsFiltered(component);\n\n    const allDependencies = await this.loadManyComponents(allIds, idStr);\n    Object.entries(component.depsIdsGroupedByType).forEach(([depType, depsIds]) => {\n      depsIds.forEach((depId) => {\n        if (this.ignoreIds.has(depId)) return;\n        if (!this.graph.hasNode(depId.toString())) {\n          throw new Error(`buildOneComponent: missing node of ${depId.toString()}`);\n        }\n        this.graph.setEdge(idStr, depId.toString(), depType);\n      });\n    });\n    this.completed.push(idStr);\n    return allDependencies;\n  }\n\n  private async loadManyComponents(componentsIds: BitId[], dependenciesOf: string): Promise<Component[]> {\n    const components = await mapSeries(componentsIds, async (comp: BitId) => {\n      const idStr = comp.toString();\n      const fromGraph = this.graph.node(idStr);\n      if (fromGraph) return fromGraph;\n      try {\n        const component = await this.loadComponent(comp);\n        this.graph.setNode(idStr, component);\n        return component;\n      } catch (err: any) {\n        if (err instanceof ComponentNotFound) {\n          throw new BitError(\n            `error: component \"${idStr}\" was not found.\\nthis component is a dependency of \"${dependenciesOf}\" and is needed as part of the graph generation`\n          );\n        }\n        this.logger.error(`failed loading dependencies of ${dependenciesOf}`);\n        throw err;\n      }\n    });\n    return components;\n  }\n  private async loadComponent(componentId: BitId): Promise<Component> {\n    const componentMap = this.consumer.bitMap.getComponentIfExist(componentId);\n    const isOnWorkspace = Boolean(componentMap);\n    if (isOnWorkspace) {\n      return this.consumer.loadComponentForCapsule(componentId);\n    }\n    // a dependency might have been installed as a package in the workspace, and as such doesn't\n    // have a componentMap.\n    const componentFromModel = await this.consumer.loadComponentFromModel(componentId);\n    return componentFromModel.clone();\n  }\n}\n"]}

package/dist/link/link.cmd.d.ts

@@ -6,6 +6,7 @@ declare type LinkCommandOpts = {
     rewire: boolean;
     verbose: boolean;
     target: string;
+    skipFetchingObjects?: boolean;
 };
 export declare class LinkCommand implements Command {
     private workspace;

package/dist/link/link.cmd.js

@@ -119,7 +119,7 @@ class LinkCommand {
     (0, _defineProperty2().default)(this, "shortDescription", 'link components and core aspects');
     (0, _defineProperty2().default)(this, "group", 'development');
     (0, _defineProperty2().default)(this, "private", false);
-    (0, _defineProperty2().default)(this, "options", [['j', 'json', 'return the output as JSON'], ['', 'verbose', 'verbose output'], ['r', 'rewire', 'Replace relative paths with module paths in code (e.g. "../foo" => "@bit/foo")'], ['', 'target <dir>', 'EXPERIMENTAL. link to an external directory (similar to npm-link) so other projects could use these components']]);
+    (0, _defineProperty2().default)(this, "options", [['j', 'json', 'return the output as JSON'], ['', 'verbose', 'verbose output'], ['r', 'rewire', 'Replace relative paths with module paths in code (e.g. "../foo" => "@bit/foo")'], ['', 'target <dir>', 'EXPERIMENTAL. link to an external directory (similar to npm-link) so other projects could use these components'], ['', 'skip-fetching-objects', 'skip fetch missing objects from remotes before linking']]);
   }
 
   async report([ids], opts) {
@@ -166,7 +166,8 @@ class LinkCommand {
       rewire: opts.rewire,
       linkCoreAspects: true,
       linkTeambitBit: true,
-      linkToDir: opts.target
+      linkToDir: opts.target,
+      fetchObject: !opts.skipFetchingObjects
     };
     const linkResults = await this.workspace.link(linkOpts);
     return linkResults;

package/dist/link/link.cmd.js.map

@@ -1 +1 @@
-{"version":3,"sources":["link.cmd.ts"],"names":["LinkCommand","constructor","workspace","logger","BASE_DOCS_DOMAIN","report","ids","opts","startTime","Date","now","linkResults","json","endTime","numOfComponents","legacyLinkResults","length","timeDiff","coreAspectsLinksWithMainAspect","coreAspectsLinks","teambitBitLink","unshift","numOfCoreAspects","title","name","coreLinks","verbose","compsLinks","componentListLinks","rewireRow","legacyCodemodResults","legacyLinkCodemodResults","nestedLinks","nestedDepsInNmLinks","targetLinks","linkToDirResults","footer","console","chalk","cyan","linkOpts","legacyLink","rewire","linkCoreAspects","linkTeambitBit","linkToDir","target","link"],"mappings":"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","sourcesContent":["import { Command, CommandOptions } from '@teambit/cli';\nimport { LinkResults } from '@teambit/dependency-resolver';\nimport { Logger } from '@teambit/logger';\nimport { BASE_DOCS_DOMAIN } from '@teambit/legacy/dist/constants';\nimport { timeFormat } from '@teambit/toolbox.time.time-format';\nimport chalk from 'chalk';\nimport { Workspace, WorkspaceLinkOptions } from '../workspace';\nimport { ComponentListLinks } from './component-list-links';\nimport { CoreAspectsLinks } from './core-aspects-links';\nimport { NestedComponentLinksLinks } from './nested-deps-in-nm-links';\nimport { RewireRow } from './rewire-row';\nimport { linkToDir } from './link-to-dir';\n\ntype LinkCommandOpts = {\n  rewire: boolean;\n  verbose: boolean;\n  target: string;\n};\nexport class LinkCommand implements Command {\n  name = 'link [ids...]';\n  alias = '';\n  description = `generate symlinks to resolve module paths for imported components.\\n  https://${BASE_DOCS_DOMAIN}/docs/dependencies#missing-links`;\n  shortDescription = 'link components and core aspects';\n  group = 'development';\n  private = false;\n  options = [\n    ['j', 'json', 'return the output as JSON'],\n    ['', 'verbose', 'verbose output'],\n    ['r', 'rewire', 'Replace relative paths with module paths in code (e.g. \"../foo\" => \"@bit/foo\")'],\n    [\n      '',\n      'target <dir>',\n      'EXPERIMENTAL. link to an external directory (similar to npm-link) so other projects could use these components',\n    ],\n  ] as CommandOptions;\n\n  constructor(\n    /**\n     * workspace extension.\n     */\n    private workspace: Workspace,\n\n    /**\n     * logger extension.\n     */\n    private logger: Logger\n  ) {}\n\n  async report([ids]: [string[]], opts: LinkCommandOpts) {\n    const startTime = Date.now();\n    const linkResults = await this.json([ids], opts);\n    const endTime = Date.now();\n    const numOfComponents = linkResults.legacyLinkResults?.length;\n    const timeDiff = timeFormat(endTime - startTime);\n    const coreAspectsLinksWithMainAspect = linkResults.coreAspectsLinks || [];\n    if (linkResults.teambitBitLink) {\n      coreAspectsLinksWithMainAspect.unshift(linkResults.teambitBitLink);\n    }\n    const numOfCoreAspects = coreAspectsLinksWithMainAspect.length;\n\n    const title = `Linked ${numOfComponents} components and ${numOfCoreAspects} core aspects to node_modules for workspace: ${this.workspace.name}`;\n    const coreLinks = CoreAspectsLinks({\n      coreAspectsLinks: coreAspectsLinksWithMainAspect,\n      verbose: opts.verbose,\n    });\n    const compsLinks = ComponentListLinks({ componentListLinks: linkResults.legacyLinkResults, verbose: opts.verbose });\n    const rewireRow = RewireRow({ legacyCodemodResults: linkResults.legacyLinkCodemodResults });\n    const nestedLinks = NestedComponentLinksLinks({\n      nestedDepsInNmLinks: linkResults.nestedDepsInNmLinks,\n      verbose: opts.verbose,\n    });\n    const targetLinks = linkToDir(linkResults.linkToDirResults);\n    const footer = `Finished. ${timeDiff}`;\n    return `${title}\\n${coreLinks}\\n${compsLinks}\\n${rewireRow}${nestedLinks}${targetLinks}${footer}`;\n  }\n\n  // eslint-disable-next-line @typescript-eslint/no-unused-vars\n  async json([ids]: [string[]], opts: LinkCommandOpts): Promise<LinkResults> {\n    this.logger.console(\n      `Linking components and core aspects to node_modules for workspaces: '${chalk.cyan(this.workspace.name)}'`\n    );\n\n    const linkOpts: WorkspaceLinkOptions = {\n      legacyLink: true,\n      rewire: opts.rewire,\n      linkCoreAspects: true,\n      linkTeambitBit: true,\n      linkToDir: opts.target,\n    };\n    const linkResults = await this.workspace.link(linkOpts);\n    return linkResults;\n  }\n}\n"]}
+{"version":3,"sources":["link.cmd.ts"],"names":["LinkCommand","constructor","workspace","logger","BASE_DOCS_DOMAIN","report","ids","opts","startTime","Date","now","linkResults","json","endTime","numOfComponents","legacyLinkResults","length","timeDiff","coreAspectsLinksWithMainAspect","coreAspectsLinks","teambitBitLink","unshift","numOfCoreAspects","title","name","coreLinks","verbose","compsLinks","componentListLinks","rewireRow","legacyCodemodResults","legacyLinkCodemodResults","nestedLinks","nestedDepsInNmLinks","targetLinks","linkToDirResults","footer","console","chalk","cyan","linkOpts","legacyLink","rewire","linkCoreAspects","linkTeambitBit","linkToDir","target","fetchObject","skipFetchingObjects","link"],"mappings":"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","sourcesContent":["import { Command, CommandOptions } from '@teambit/cli';\nimport { LinkResults } from '@teambit/dependency-resolver';\nimport { Logger } from '@teambit/logger';\nimport { BASE_DOCS_DOMAIN } from '@teambit/legacy/dist/constants';\nimport { timeFormat } from '@teambit/toolbox.time.time-format';\nimport chalk from 'chalk';\nimport { Workspace, WorkspaceLinkOptions } from '../workspace';\nimport { ComponentListLinks } from './component-list-links';\nimport { CoreAspectsLinks } from './core-aspects-links';\nimport { NestedComponentLinksLinks } from './nested-deps-in-nm-links';\nimport { RewireRow } from './rewire-row';\nimport { linkToDir } from './link-to-dir';\n\ntype LinkCommandOpts = {\n  rewire: boolean;\n  verbose: boolean;\n  target: string;\n  skipFetchingObjects?: boolean;\n};\nexport class LinkCommand implements Command {\n  name = 'link [ids...]';\n  alias = '';\n  description = `generate symlinks to resolve module paths for imported components.\\n  https://${BASE_DOCS_DOMAIN}/docs/dependencies#missing-links`;\n  shortDescription = 'link components and core aspects';\n  group = 'development';\n  private = false;\n  options = [\n    ['j', 'json', 'return the output as JSON'],\n    ['', 'verbose', 'verbose output'],\n    ['r', 'rewire', 'Replace relative paths with module paths in code (e.g. \"../foo\" => \"@bit/foo\")'],\n    [\n      '',\n      'target <dir>',\n      'EXPERIMENTAL. link to an external directory (similar to npm-link) so other projects could use these components',\n    ],\n    ['', 'skip-fetching-objects', 'skip fetch missing objects from remotes before linking'],\n  ] as CommandOptions;\n\n  constructor(\n    /**\n     * workspace extension.\n     */\n    private workspace: Workspace,\n\n    /**\n     * logger extension.\n     */\n    private logger: Logger\n  ) {}\n\n  async report([ids]: [string[]], opts: LinkCommandOpts) {\n    const startTime = Date.now();\n    const linkResults = await this.json([ids], opts);\n    const endTime = Date.now();\n    const numOfComponents = linkResults.legacyLinkResults?.length;\n    const timeDiff = timeFormat(endTime - startTime);\n    const coreAspectsLinksWithMainAspect = linkResults.coreAspectsLinks || [];\n    if (linkResults.teambitBitLink) {\n      coreAspectsLinksWithMainAspect.unshift(linkResults.teambitBitLink);\n    }\n    const numOfCoreAspects = coreAspectsLinksWithMainAspect.length;\n\n    const title = `Linked ${numOfComponents} components and ${numOfCoreAspects} core aspects to node_modules for workspace: ${this.workspace.name}`;\n    const coreLinks = CoreAspectsLinks({\n      coreAspectsLinks: coreAspectsLinksWithMainAspect,\n      verbose: opts.verbose,\n    });\n    const compsLinks = ComponentListLinks({ componentListLinks: linkResults.legacyLinkResults, verbose: opts.verbose });\n    const rewireRow = RewireRow({ legacyCodemodResults: linkResults.legacyLinkCodemodResults });\n    const nestedLinks = NestedComponentLinksLinks({\n      nestedDepsInNmLinks: linkResults.nestedDepsInNmLinks,\n      verbose: opts.verbose,\n    });\n    const targetLinks = linkToDir(linkResults.linkToDirResults);\n    const footer = `Finished. ${timeDiff}`;\n    return `${title}\\n${coreLinks}\\n${compsLinks}\\n${rewireRow}${nestedLinks}${targetLinks}${footer}`;\n  }\n\n  // eslint-disable-next-line @typescript-eslint/no-unused-vars\n  async json([ids]: [string[]], opts: LinkCommandOpts): Promise<LinkResults> {\n    this.logger.console(\n      `Linking components and core aspects to node_modules for workspaces: '${chalk.cyan(this.workspace.name)}'`\n    );\n\n    const linkOpts: WorkspaceLinkOptions = {\n      legacyLink: true,\n      rewire: opts.rewire,\n      linkCoreAspects: true,\n      linkTeambitBit: true,\n      linkToDir: opts.target,\n      fetchObject: !opts.skipFetchingObjects,\n    };\n    const linkResults = await this.workspace.link(linkOpts);\n    return linkResults;\n  }\n}\n"]}

package/dist/workspace.d.ts

@@ -14,8 +14,9 @@ import { RequireableComponent } from '@teambit/harmony.modules.requireable-compo
 import { ResolvedComponent } from '@teambit/harmony.modules.resolved-component';
 import type { VariantsMain } from '@teambit/variants';
 import LegacyGraph from '@teambit/legacy/dist/scope/graph/graph';
+import { BitIds } from '@teambit/legacy/dist/bit-id';
 import { BitId } from '@teambit/legacy-bit-id';
-import { LocalLaneId } from '@teambit/legacy/dist/lane-id/lane-id';
+import { LocalLaneId, RemoteLaneId } from '@teambit/legacy/dist/lane-id/lane-id';
 import { Consumer } from '@teambit/legacy/dist/consumer';
 import { GetBitMapComponentOptions } from '@teambit/legacy/dist/consumer/bit-map/bit-map';
 import type { AddActionResults, Warnings } from '@teambit/legacy/dist/consumer/component-ops/add-components/add-components';
@@ -31,6 +32,7 @@ import { Watcher, WatchOptions } from './watch/watcher';
 import { ComponentStatus } from './workspace-component/component-status';
 import { OnComponentAddSlot, OnComponentChangeSlot, OnComponentLoadSlot, OnComponentRemoveSlot, OnPreWatch, OnPreWatchSlot } from './workspace.provider';
 import { WorkspaceComponentLoader } from './workspace-component/workspace-component-loader';
+import { ShouldIgnoreFunc } from './build-graph-from-fs';
 export declare type EjectConfResult = {
     configPath: string;
 };
@@ -130,6 +132,7 @@ export declare class Workspace implements ComponentFactory {
     getState(id: ComponentID, hash: string): Promise<import("@teambit/component").State>;
     getSnap(id: ComponentID, hash: string): Promise<import("@teambit/component").Snap>;
     getCurrentLaneId(): LocalLaneId;
+    getCurrentRemoteLaneId(): RemoteLaneId | null;
     getDefaultExtensions(): ExtensionDataList;
     ejectConfig(id: ComponentID, options: EjectConfOptions): Promise<EjectConfResult>;
     private resolveScopeAspectListIds;
@@ -159,8 +162,9 @@ export declare class Workspace implements ComponentFactory {
     private isVendorComponentByComponentDir;
     private componentConfigFile;
     private componentConfigFileFromComponentDirAndName;
-    getGraphWithoutCore(components: Component[]): Promise<LegacyGraph>;
+    getAspectsGraphWithoutCore(components: Component[], isAspect?: ShouldIgnoreFunc): Promise<LegacyGraph>;
     loadAspects(ids?: string[], throwOnError?: boolean): Promise<void>;
+    buildOneGraphForComponents(ids: BitId[], ignoreIds?: BitIds, shouldIgnoreFunc?: ShouldIgnoreFunc): Promise<LegacyGraph>;
     resolveAspects(runtimeName?: string, componentIds?: ComponentID[]): Promise<AspectDefinition[]>;
     private groupIdsByWorkspaceAndScope;
     private groupComponentsByWorkspaceAndScope;