@teambit/workspace 0.0.886 → 0.0.888

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

@@ -1,9 +1,8 @@
-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 { Graph } from '@teambit/graph.cleargraph';
+import { Component, ComponentID } from '@teambit/component';
 import { Logger } from '@teambit/logger';
 import { Workspace } from './workspace';
-export declare type ShouldLoadFunc = (bitId: BitId) => Promise<boolean>;
+export declare type ShouldLoadFunc = (id: ComponentID) => Promise<boolean>;
 export declare class GraphFromFsBuilder {
     private workspace;
     private logger;
@@ -14,7 +13,9 @@ export declare class GraphFromFsBuilder {
     private completed;
     private depth;
     private consumer;
-    constructor(workspace: Workspace, logger: Logger, ignoreIds?: BitIds, shouldLoadItsDeps?: ShouldLoadFunc | undefined, shouldThrowOnMissingDep?: boolean);
+    private legacyIdStrToComponentId;
+    private importedIds;
+    constructor(workspace: Workspace, logger: Logger, ignoreIds?: string[], shouldLoadItsDeps?: ShouldLoadFunc | undefined, shouldThrowOnMissingDep?: boolean);
     /**
      * 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.
@@ -45,12 +46,17 @@ export declare class GraphFromFsBuilder {
      * 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.
      */
-    buildGraph(ids: BitId[]): Promise<LegacyGraph>;
+    buildGraph(ids: ComponentID[]): Promise<Graph<Component, string>>;
     private getAllDepsUnfiltered;
     private getAllDepsFiltered;
     private processManyComponents;
+    /**
+     * 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 importObjects;
     private processOneComponent;
     private loadManyComponents;
-    private loadComponent;
 }

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

@@ -23,6 +23,13 @@ function _pMapSeries() {
   };
   return data;
 }
+function _graph() {
+  const data = require("@teambit/graph.cleargraph");
+  _graph = function () {
+    return data;
+  };
+  return data;
+}
 function _lodash() {
   const data = require("lodash");
   _lodash = function () {
@@ -37,20 +44,6 @@ function _bitIds() {
   };
   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 _exceptions() {
   const data = require("@teambit/legacy/dist/scope/exceptions");
   _exceptions = function () {
@@ -80,16 +73,18 @@ function _bitError() {
   return data;
 }
 class GraphFromFsBuilder {
-  constructor(workspace, logger, ignoreIds = new (_bitIds().default)(), shouldLoadItsDeps, shouldThrowOnMissingDep = true) {
+  constructor(workspace, logger, ignoreIds = [], shouldLoadItsDeps, shouldThrowOnMissingDep = true) {
     this.workspace = workspace;
     this.logger = logger;
     this.ignoreIds = ignoreIds;
     this.shouldLoadItsDeps = shouldLoadItsDeps;
     this.shouldThrowOnMissingDep = shouldThrowOnMissingDep;
-    (0, _defineProperty2().default)(this, "graph", new (_graph().default)());
+    (0, _defineProperty2().default)(this, "graph", new (_graph().Graph)());
     (0, _defineProperty2().default)(this, "completed", []);
     (0, _defineProperty2().default)(this, "depth", 1);
     (0, _defineProperty2().default)(this, "consumer", void 0);
+    (0, _defineProperty2().default)(this, "legacyIdStrToComponentId", {});
+    (0, _defineProperty2().default)(this, "importedIds", []);
     this.consumer = this.workspace.consumer;
   }
 
@@ -131,19 +126,27 @@ class GraphFromFsBuilder {
     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 getAllDepsUnfiltered(component) {
+    const consumerComp = component.state._consumer;
+    const legacyDepsIds = consumerComp.getAllDependenciesIds();
+    const depsIds = await Promise.all(legacyDepsIds.map(async bitId => {
+      if (!this.legacyIdStrToComponentId[bitId.toString()]) {
+        this.legacyIdStrToComponentId[bitId.toString()] = await this.workspace.resolveComponentId(bitId);
+      }
+      return this.legacyIdStrToComponentId[bitId.toString()];
+    }));
+    return depsIds.filter(depId => !this.ignoreIds.includes(depId.toString()));
   }
   async getAllDepsFiltered(component) {
-    const depsWithoutIgnore = this.getAllDepsUnfiltered(component);
+    const depsWithoutIgnore = await 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);
+      if (!shouldLoad) this.ignoreIds.push(depId.toString());
       return shouldLoad ? depId : null;
     });
-    return _bitIds().default.fromArray((0, _lodash2().default)(deps));
+    return (0, _lodash2().default)(deps);
   }
   async processManyComponents(components) {
     this.logger.debug(`GraphFromFsBuilder.processManyComponents depth ${this.depth}, ${components.length} components`);
@@ -153,25 +156,39 @@ class GraphFromFsBuilder {
     const allDependenciesFlattened = (0, _lodash().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.
+   */
   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);
+    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 allDepsWithScope = allDepsNotImported.map(id => id._legacy).filter(dep => dep.hasScope());
+    const scopeComponentsImporter = this.consumer.scope.scopeImporter;
     await scopeComponentsImporter.importMany({
       ids: _bitIds().default.uniqFromArray(allDepsWithScope),
       throwForDependencyNotFound: this.shouldThrowOnMissingDep,
       throwForSeederNotFound: this.shouldThrowOnMissingDep,
       reFetchUnBuiltVersion: false
     });
+    allDepsNotImported.map(id => this.importedIds.push(id.toString()));
   }
   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;
+    const consumerComponent = component.state._consumer;
+    Object.entries(consumerComponent.depsIdsGroupedByType).forEach(([depType, depsIds]) => {
+      depsIds.forEach(depBitId => {
+        const depId = this.legacyIdStrToComponentId[depBitId.toString()];
+        if (!depId) throw new Error(`unable to find ${depBitId.toString()} inside legacyIdStrToComponentId`);
+        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()}`);
@@ -179,7 +196,7 @@ class GraphFromFsBuilder {
           this.logger.warn(`ignoring missing ${depId.toString()}`);
           return;
         }
-        this.graph.setEdge(idStr, depId.toString(), depType);
+        this.graph.setEdge(new (_graph().Edge)(idStr, depId.toString(), depType));
       });
     });
     this.completed.push(idStr);
@@ -187,12 +204,13 @@ class GraphFromFsBuilder {
   }
   async loadManyComponents(componentsIds, dependenciesOf) {
     const components = await (0, _pMapSeries().default)(componentsIds, async comp => {
+      var _this$graph$node;
       const idStr = comp.toString();
-      const fromGraph = this.graph.node(idStr);
+      const fromGraph = (_this$graph$node = this.graph.node(idStr)) === null || _this$graph$node === void 0 ? void 0 : _this$graph$node.attr;
       if (fromGraph) return fromGraph;
       try {
-        const component = await this.loadComponent(comp);
-        this.graph.setNode(idStr, component);
+        const component = await this.workspace.get(comp);
+        this.graph.setNode(new (_graph().Node)(idStr, component));
         return component;
       } catch (err) {
         if (err instanceof _exceptions().ComponentNotFound || err instanceof _scope().ComponentNotFound || err instanceof _exceptions().ScopeNotFound) {
@@ -208,11 +226,6 @@ class GraphFromFsBuilder {
     });
     return (0, _lodash2().default)(components);
   }
-  async loadComponent(componentId) {
-    const compId = await this.workspace.resolveComponentId(componentId);
-    const comp = await this.workspace.get(compId);
-    return comp.state._consumer;
-  }
 }
 exports.GraphFromFsBuilder = GraphFromFsBuilder;
 

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

@@ -1 +1 @@
-{"version":3,"names":["GraphFromFsBuilder","constructor","workspace","logger","ignoreIds","BitIds","shouldLoadItsDeps","shouldThrowOnMissingDep","LegacyGraph","consumer","buildGraph","ids","debug","length","start","Date","now","components","loadManyComponents","processManyComponents","graph","getAllDepsUnfiltered","component","getAllDependenciesIds","difference","getAllDepsFiltered","depsWithoutIgnore","shouldLoadFunc","deps","mapSeries","depId","shouldLoad","push","fromArray","compact","depth","importObjects","allDependencies","processOneComponent","allDependenciesFlattened","flatten","allDeps","map","c","flat","allDepsWithScope","filter","dep","hasScope","scopeComponentsImporter","ScopeComponentsImporter","scope","importMany","uniqFromArray","throwForDependencyNotFound","throwForSeederNotFound","reFetchUnBuiltVersion","idStr","id","toString","completed","includes","allIds","Object","entries","depsIdsGroupedByType","forEach","depType","depsIds","has","hasNode","Error","warn","setEdge","componentsIds","dependenciesOf","comp","fromGraph","node","loadComponent","setNode","err","ComponentNotFound","ComponentNotFoundInScope","ScopeNotFound","BitError","error","componentId","compId","resolveComponentId","get","state","_consumer"],"sources":["build-graph-from-fs.ts"],"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 { ComponentNotFound, ScopeNotFound } from '@teambit/legacy/dist/scope/exceptions';\nimport { ComponentNotFound as ComponentNotFoundInScope } from '@teambit/scope';\nimport compact from 'lodash.compact';\nimport { BitId } from '@teambit/legacy-bit-id';\nimport { Logger } from '@teambit/logger';\nimport { BitError } from '@teambit/bit-error';\nimport { Workspace } from './workspace';\n\nexport type ShouldLoadFunc = (bitId: BitId) => Promise<boolean>;\n\nexport class GraphFromFsBuilder {\n  private graph = new LegacyGraph();\n  private completed: string[] = [];\n  private depth = 1;\n  private consumer: Consumer;\n  constructor(\n    private workspace: Workspace,\n    private logger: Logger,\n    private ignoreIds = new BitIds(),\n    private shouldLoadItsDeps?: ShouldLoadFunc,\n    private shouldThrowOnMissingDep = true\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);\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      ids: BitIds.uniqFromArray(allDepsWithScope),\n      throwForDependencyNotFound: this.shouldThrowOnMissingDep,\n      throwForSeederNotFound: this.shouldThrowOnMissingDep,\n      reFetchUnBuiltVersion: false,\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          if (this.shouldThrowOnMissingDep) {\n            throw new Error(`buildOneComponent: missing node of ${depId.toString()}`);\n          }\n          this.logger.warn(`ignoring missing ${depId.toString()}`);\n          return;\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 (\n          err instanceof ComponentNotFound ||\n          err instanceof ComponentNotFoundInScope ||\n          err instanceof ScopeNotFound\n        ) {\n          if (dependenciesOf && !this.shouldThrowOnMissingDep) {\n            this.logger.warn(\n              `component ${idStr}, dependency of ${dependenciesOf} was not found. continuing without it`\n            );\n            return null;\n          }\n          throw new BitError(\n            `error: component \"${idStr}\" was not found.\\nthis component is a dependency of \"${\n              dependenciesOf || '<none>'\n            }\" and is needed as part of the graph generation`\n          );\n        }\n        if (dependenciesOf) this.logger.error(`failed loading dependencies of ${dependenciesOf}`);\n        throw err;\n      }\n    });\n    return compact(components);\n  }\n  private async loadComponent(componentId: BitId): Promise<Component> {\n    const compId = await this.workspace.resolveComponentId(componentId);\n    const comp = await this.workspace.get(compId);\n    return comp.state._consumer;\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;AAAA;EAAA;EAAA;IAAA;EAAA;EAAA;AAAA;AACA;EAAA;EAAA;IAAA;EAAA;EAAA;AAAA;AAEA;EAAA;EAAA;IAAA;EAAA;EAAA;AAAA;AAEA;EAAA;EAAA;IAAA;EAAA;EAAA;AAAA;AACA;EAAA;EAAA;IAAA;EAAA;EAAA;AAAA;AACA;EAAA;EAAA;IAAA;EAAA;EAAA;AAAA;AACA;EAAA;EAAA;IAAA;EAAA;EAAA;AAAA;AACA;EAAA;EAAA;IAAA;EAAA;EAAA;AAAA;AAGA;EAAA;EAAA;IAAA;EAAA;EAAA;AAAA;AAKO,MAAMA,kBAAkB,CAAC;EAK9BC,WAAW,CACDC,SAAoB,EACpBC,MAAc,EACdC,SAAS,GAAG,KAAIC,iBAAM,GAAE,EACxBC,iBAAkC,EAClCC,uBAAuB,GAAG,IAAI,EACtC;IAAA,KALQL,SAAoB,GAApBA,SAAoB;IAAA,KACpBC,MAAc,GAAdA,MAAc;IAAA,KACdC,SAAS,GAATA,SAAS;IAAA,KACTE,iBAAkC,GAAlCA,iBAAkC;IAAA,KAClCC,uBAAuB,GAAvBA,uBAAuB;IAAA,+CATjB,KAAIC,gBAAW,GAAE;IAAA,mDACH,EAAE;IAAA,+CAChB,CAAC;IAAA;IASf,IAAI,CAACC,QAAQ,GAAG,IAAI,CAACP,SAAS,CAACO,QAAQ;EACzC;;EAEA;AACF;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;EACE,MAAMC,UAAU,CAACC,GAAY,EAAwB;IACnD,IAAI,CAACR,MAAM,CAACS,KAAK,CAAE,uCAAsCD,GAAG,CAACE,MAAO,UAAS,CAAC;IAC9E,MAAMC,KAAK,GAAGC,IAAI,CAACC,GAAG,EAAE;IACxB,MAAMC,UAAU,GAAG,MAAM,IAAI,CAACC,kBAAkB,CAACP,GAAG,CAAC;IACrD,MAAM,IAAI,CAACQ,qBAAqB,CAACF,UAAU,CAAC;IAC5C,IAAI,CAACd,MAAM,CAACS,KAAK,CACd,uCAAsCD,GAAG,CAACE,MAAO,uBAAsB,CAACE,IAAI,CAACC,GAAG,EAAE,GAAGF,KAAK,IAAI,IAAK,OAAM,CAC3G;IACD,OAAO,IAAI,CAACM,KAAK;EACnB;EAEQC,oBAAoB,CAACC,SAAoB,EAAE;IACjD,OAAOA,SAAS,CAACC,qBAAqB,EAAE,CAACC,UAAU,CAAC,IAAI,CAACpB,SAAS,CAAC;EACrE;EAEA,MAAcqB,kBAAkB,CAACH,SAAoB,EAAmB;IACtE,MAAMI,iBAAiB,GAAG,IAAI,CAACL,oBAAoB,CAACC,SAAS,CAAC;IAC9D,MAAMK,cAAc,GAAG,IAAI,CAACrB,iBAAiB;IAC7C,IAAI,CAACqB,cAAc,EAAE,OAAOD,iBAAiB;IAC7C,MAAME,IAAI,GAAG,MAAM,IAAAC,qBAAS,EAACH,iBAAiB,EAAE,MAAOI,KAAK,IAAK;MAC/D,MAAMC,UAAU,GAAG,MAAMJ,cAAc,CAACG,KAAK,CAAC;MAC9C,IAAI,CAACC,UAAU,EAAE,IAAI,CAAC3B,SAAS,CAAC4B,IAAI,CAACF,KAAK,CAAC;MAC3C,OAAOC,UAAU,GAAGD,KAAK,GAAG,IAAI;IAClC,CAAC,CAAC;IACF,OAAOzB,iBAAM,CAAC4B,SAAS,CAAC,IAAAC,kBAAO,EAACN,IAAI,CAAC,CAAC;EACxC;EAEA,MAAcT,qBAAqB,CAACF,UAAuB,EAAE;IAC3D,IAAI,CAACd,MAAM,CAACS,KAAK,CAAE,kDAAiD,IAAI,CAACuB,KAAM,KAAIlB,UAAU,CAACJ,MAAO,aAAY,CAAC;IAClH,IAAI,CAACsB,KAAK,IAAI,CAAC;IACf,MAAM,IAAI,CAACC,aAAa,CAACnB,UAAU,CAAC;IACpC,MAAMoB,eAAe,GAAG,MAAM,IAAAR,qBAAS,EAACZ,UAAU,EAAGK,SAAS,IAAK,IAAI,CAACgB,mBAAmB,CAAChB,SAAS,CAAC,CAAC;IACvG,MAAMiB,wBAAwB,GAAG,IAAAC,iBAAO,EAACH,eAAe,CAAC;IACzD,IAAIE,wBAAwB,CAAC1B,MAAM,EAAE,MAAM,IAAI,CAACM,qBAAqB,CAACoB,wBAAwB,CAAC;EACjG;EAEA,MAAcH,aAAa,CAACnB,UAAuB,EAAE;IACnD,MAAMwB,OAAO,GAAGxB,UAAU,CAACyB,GAAG,CAAEC,CAAC,IAAK,IAAI,CAACtB,oBAAoB,CAACsB,CAAC,CAAC,CAAC,CAACC,IAAI,EAAE;IAC1E,MAAMC,gBAAgB,GAAGJ,OAAO,CAACK,MAAM,CAAEC,GAAG,IAAKA,GAAG,CAACC,QAAQ,EAAE,CAAC;IAChE,MAAMC,uBAAuB,GAAG,KAAIC,kCAAuB,EAAC,IAAI,CAACzC,QAAQ,CAAC0C,KAAK,CAAC;IAChF,MAAMF,uBAAuB,CAACG,UAAU,CAAC;MACvCzC,GAAG,EAAEN,iBAAM,CAACgD,aAAa,CAACR,gBAAgB,CAAC;MAC3CS,0BAA0B,EAAE,IAAI,CAAC/C,uBAAuB;MACxDgD,sBAAsB,EAAE,IAAI,CAAChD,uBAAuB;MACpDiD,qBAAqB,EAAE;IACzB,CAAC,CAAC;EACJ;EAEA,MAAclB,mBAAmB,CAAChB,SAAoB,EAAE;IACtD,MAAMmC,KAAK,GAAGnC,SAAS,CAACoC,EAAE,CAACC,QAAQ,EAAE;IACrC,IAAI,IAAI,CAACC,SAAS,CAACC,QAAQ,CAACJ,KAAK,CAAC,EAAE,OAAO,EAAE;IAC7C,MAAMK,MAAM,GAAG,MAAM,IAAI,CAACrC,kBAAkB,CAACH,SAAS,CAAC;IAEvD,MAAMe,eAAe,GAAG,MAAM,IAAI,CAACnB,kBAAkB,CAAC4C,MAAM,EAAEL,KAAK,CAAC;IACpEM,MAAM,CAACC,OAAO,CAAC1C,SAAS,CAAC2C,oBAAoB,CAAC,CAACC,OAAO,CAAC,CAAC,CAACC,OAAO,EAAEC,OAAO,CAAC,KAAK;MAC7EA,OAAO,CAACF,OAAO,CAAEpC,KAAK,IAAK;QACzB,IAAI,IAAI,CAAC1B,SAAS,CAACiE,GAAG,CAACvC,KAAK,CAAC,EAAE;QAC/B,IAAI,CAAC,IAAI,CAACV,KAAK,CAACkD,OAAO,CAACxC,KAAK,CAAC6B,QAAQ,EAAE,CAAC,EAAE;UACzC,IAAI,IAAI,CAACpD,uBAAuB,EAAE;YAChC,MAAM,IAAIgE,KAAK,CAAE,sCAAqCzC,KAAK,CAAC6B,QAAQ,EAAG,EAAC,CAAC;UAC3E;UACA,IAAI,CAACxD,MAAM,CAACqE,IAAI,CAAE,oBAAmB1C,KAAK,CAAC6B,QAAQ,EAAG,EAAC,CAAC;UACxD;QACF;QACA,IAAI,CAACvC,KAAK,CAACqD,OAAO,CAAChB,KAAK,EAAE3B,KAAK,CAAC6B,QAAQ,EAAE,EAAEQ,OAAO,CAAC;MACtD,CAAC,CAAC;IACJ,CAAC,CAAC;IACF,IAAI,CAACP,SAAS,CAAC5B,IAAI,CAACyB,KAAK,CAAC;IAC1B,OAAOpB,eAAe;EACxB;EAEA,MAAcnB,kBAAkB,CAACwD,aAAsB,EAAEC,cAAuB,EAAwB;IACtG,MAAM1D,UAAU,GAAG,MAAM,IAAAY,qBAAS,EAAC6C,aAAa,EAAE,MAAOE,IAAW,IAAK;MACvE,MAAMnB,KAAK,GAAGmB,IAAI,CAACjB,QAAQ,EAAE;MAC7B,MAAMkB,SAAS,GAAG,IAAI,CAACzD,KAAK,CAAC0D,IAAI,CAACrB,KAAK,CAAC;MACxC,IAAIoB,SAAS,EAAE,OAAOA,SAAS;MAC/B,IAAI;QACF,MAAMvD,SAAS,GAAG,MAAM,IAAI,CAACyD,aAAa,CAACH,IAAI,CAAC;QAChD,IAAI,CAACxD,KAAK,CAAC4D,OAAO,CAACvB,KAAK,EAAEnC,SAAS,CAAC;QACpC,OAAOA,SAAS;MAClB,CAAC,CAAC,OAAO2D,GAAQ,EAAE;QACjB,IACEA,GAAG,YAAYC,+BAAiB,IAChCD,GAAG,YAAYE,0BAAwB,IACvCF,GAAG,YAAYG,2BAAa,EAC5B;UACA,IAAIT,cAAc,IAAI,CAAC,IAAI,CAACpE,uBAAuB,EAAE;YACnD,IAAI,CAACJ,MAAM,CAACqE,IAAI,CACb,aAAYf,KAAM,mBAAkBkB,cAAe,uCAAsC,CAC3F;YACD,OAAO,IAAI;UACb;UACA,MAAM,KAAIU,oBAAQ,EACf,qBAAoB5B,KAAM,wDACzBkB,cAAc,IAAI,QACnB,iDAAgD,CAClD;QACH;QACA,IAAIA,cAAc,EAAE,IAAI,CAACxE,MAAM,CAACmF,KAAK,CAAE,kCAAiCX,cAAe,EAAC,CAAC;QACzF,MAAMM,GAAG;MACX;IACF,CAAC,CAAC;IACF,OAAO,IAAA/C,kBAAO,EAACjB,UAAU,CAAC;EAC5B;EACA,MAAc8D,aAAa,CAACQ,WAAkB,EAAsB;IAClE,MAAMC,MAAM,GAAG,MAAM,IAAI,CAACtF,SAAS,CAACuF,kBAAkB,CAACF,WAAW,CAAC;IACnE,MAAMX,IAAI,GAAG,MAAM,IAAI,CAAC1E,SAAS,CAACwF,GAAG,CAACF,MAAM,CAAC;IAC7C,OAAOZ,IAAI,CAACe,KAAK,CAACC,SAAS;EAC7B;AACF;AAAC"}
+{"version":3,"names":["GraphFromFsBuilder","constructor","workspace","logger","ignoreIds","shouldLoadItsDeps","shouldThrowOnMissingDep","Graph","consumer","buildGraph","ids","debug","length","start","Date","now","components","loadManyComponents","processManyComponents","graph","getAllDepsUnfiltered","component","consumerComp","state","_consumer","legacyDepsIds","getAllDependenciesIds","depsIds","Promise","all","map","bitId","legacyIdStrToComponentId","toString","resolveComponentId","filter","depId","includes","getAllDepsFiltered","depsWithoutIgnore","shouldLoadFunc","deps","mapSeries","shouldLoad","push","compact","depth","importObjects","allDependencies","processOneComponent","allDependenciesFlattened","flatten","workspaceIds","listIds","compOnWorkspaceOnly","comp","find","id","isEqual","allDeps","c","flat","allDepsNotImported","d","importedIds","allDepsWithScope","_legacy","dep","hasScope","scopeComponentsImporter","scope","scopeImporter","importMany","BitIds","uniqFromArray","throwForDependencyNotFound","throwForSeederNotFound","reFetchUnBuiltVersion","idStr","completed","allIds","consumerComponent","Object","entries","depsIdsGroupedByType","forEach","depType","depBitId","Error","hasNode","warn","setEdge","Edge","componentsIds","dependenciesOf","fromGraph","node","attr","get","setNode","Node","err","ComponentNotFound","ComponentNotFoundInScope","ScopeNotFound","BitError","error"],"sources":["build-graph-from-fs.ts"],"sourcesContent":["import mapSeries from 'p-map-series';\nimport { Graph, Node, Edge } from '@teambit/graph.cleargraph';\nimport { flatten } from 'lodash';\nimport { Consumer } from '@teambit/legacy/dist/consumer';\nimport { Component, ComponentID } from '@teambit/component';\nimport BitIds from '@teambit/legacy/dist/bit-id/bit-ids';\nimport ConsumerComponent from '@teambit/legacy/dist/consumer/component/consumer-component';\nimport { ComponentNotFound, ScopeNotFound } from '@teambit/legacy/dist/scope/exceptions';\nimport { ComponentNotFound as ComponentNotFoundInScope } from '@teambit/scope';\nimport compact from 'lodash.compact';\nimport { Logger } from '@teambit/logger';\nimport { BitError } from '@teambit/bit-error';\nimport { Workspace } from './workspace';\n\nexport type ShouldLoadFunc = (id: ComponentID) => Promise<boolean>;\n\nexport class GraphFromFsBuilder {\n  private graph = new Graph<Component, string>();\n  private completed: string[] = [];\n  private depth = 1;\n  private consumer: Consumer;\n  private legacyIdStrToComponentId: { [bitIdStr: string]: ComponentID } = {};\n  private importedIds: string[] = [];\n  constructor(\n    private workspace: Workspace,\n    private logger: Logger,\n    private ignoreIds: string[] = [],\n    private shouldLoadItsDeps?: ShouldLoadFunc,\n    private shouldThrowOnMissingDep = true\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: ComponentID[]): Promise<Graph<Component, string>> {\n    this.logger.debug(`GraphFromFsBuilder, buildGraph with ${ids.length} seeders`);\n    const start = Date.now();\n    const components = await this.loadManyComponents(ids);\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 async getAllDepsUnfiltered(component: Component): Promise<ComponentID[]> {\n    const consumerComp = component.state._consumer as ConsumerComponent;\n    const legacyDepsIds = consumerComp.getAllDependenciesIds();\n    const depsIds = await Promise.all(\n      legacyDepsIds.map(async (bitId) => {\n        if (!this.legacyIdStrToComponentId[bitId.toString()]) {\n          this.legacyIdStrToComponentId[bitId.toString()] = await this.workspace.resolveComponentId(bitId);\n        }\n        return this.legacyIdStrToComponentId[bitId.toString()];\n      })\n    );\n    return depsIds.filter((depId) => !this.ignoreIds.includes(depId.toString()));\n  }\n\n  private async getAllDepsFiltered(component: Component): Promise<ComponentID[]> {\n    const depsWithoutIgnore = await 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.toString());\n      return shouldLoad ? depId : null;\n    });\n    return 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  /**\n   * only for components from the workspace that can be modified to add/remove dependencies, we need to make sure that\n   * all their dependencies are imported.\n   * remember that `importMany` fetches all flattened dependencies. once a component from scope is imported, we know\n   * that all its flattened dependencies are there. no need to call importMany again for them.\n   */\n  private async importObjects(components: Component[]) {\n    const workspaceIds = await this.workspace.listIds();\n    const compOnWorkspaceOnly = components.filter((comp) => workspaceIds.find((id) => id.isEqual(comp.id)));\n    const allDeps = (await Promise.all(compOnWorkspaceOnly.map((c) => this.getAllDepsUnfiltered(c)))).flat();\n    const allDepsNotImported = allDeps.filter((d) => !this.importedIds.includes(d.toString()));\n    const allDepsWithScope = allDepsNotImported.map((id) => id._legacy).filter((dep) => dep.hasScope());\n    const scopeComponentsImporter = this.consumer.scope.scopeImporter;\n    await scopeComponentsImporter.importMany({\n      ids: BitIds.uniqFromArray(allDepsWithScope),\n      throwForDependencyNotFound: this.shouldThrowOnMissingDep,\n      throwForSeederNotFound: this.shouldThrowOnMissingDep,\n      reFetchUnBuiltVersion: false,\n    });\n    allDepsNotImported.map((id) => this.importedIds.push(id.toString()));\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    const consumerComponent = component.state._consumer as ConsumerComponent;\n    Object.entries(consumerComponent.depsIdsGroupedByType).forEach(([depType, depsIds]) => {\n      depsIds.forEach((depBitId) => {\n        const depId = this.legacyIdStrToComponentId[depBitId.toString()];\n        if (!depId) throw new Error(`unable to find ${depBitId.toString()} inside legacyIdStrToComponentId`);\n        if (this.ignoreIds.includes(depId.toString())) return;\n        if (!this.graph.hasNode(depId.toString())) {\n          if (this.shouldThrowOnMissingDep) {\n            throw new Error(`buildOneComponent: missing node of ${depId.toString()}`);\n          }\n          this.logger.warn(`ignoring missing ${depId.toString()}`);\n          return;\n        }\n        this.graph.setEdge(new Edge(idStr, depId.toString(), depType));\n      });\n    });\n    this.completed.push(idStr);\n    return allDependencies;\n  }\n\n  private async loadManyComponents(componentsIds: ComponentID[], dependenciesOf?: string): Promise<Component[]> {\n    const components = await mapSeries(componentsIds, async (comp) => {\n      const idStr = comp.toString();\n      const fromGraph = this.graph.node(idStr)?.attr;\n      if (fromGraph) return fromGraph;\n      try {\n        const component = await this.workspace.get(comp);\n        this.graph.setNode(new Node(idStr, component));\n        return component;\n      } catch (err: any) {\n        if (\n          err instanceof ComponentNotFound ||\n          err instanceof ComponentNotFoundInScope ||\n          err instanceof ScopeNotFound\n        ) {\n          if (dependenciesOf && !this.shouldThrowOnMissingDep) {\n            this.logger.warn(\n              `component ${idStr}, dependency of ${dependenciesOf} was not found. continuing without it`\n            );\n            return null;\n          }\n          throw new BitError(\n            `error: component \"${idStr}\" was not found.\\nthis component is a dependency of \"${\n              dependenciesOf || '<none>'\n            }\" and is needed as part of the graph generation`\n          );\n        }\n        if (dependenciesOf) this.logger.error(`failed loading dependencies of ${dependenciesOf}`);\n        throw err;\n      }\n    });\n    return compact(components);\n  }\n}\n"],"mappings":"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"}

package/dist/ui/workspace/use-workspace.d.ts

@@ -14,12 +14,12 @@ export declare function useWorkspace(options?: UseWorkspaceOptions): {
     loading: boolean;
     networkStatus: import("@apollo/client").NetworkStatus;
     called: boolean;
-    variables: import("@apollo/client").OperationVariables | undefined;
     startPolling: (pollInterval: number) => void;
     stopPolling: () => void;
     updateQuery: <TVars = import("@apollo/client").OperationVariables>(mapFn: (previousQueryResult: any, options: Pick<import("@apollo/client").WatchQueryOptions<TVars, any>, "variables">) => any) => void;
     refetch: (variables?: Partial<import("@apollo/client").OperationVariables> | undefined) => Promise<import("@apollo/client").ApolloQueryResult<any>>;
     reobserve: (newOptions?: Partial<import("@apollo/client").WatchQueryOptions<import("@apollo/client").OperationVariables, any>> | undefined, newNetworkStatus?: import("@apollo/client").NetworkStatus | undefined) => Promise<import("@apollo/client").ApolloQueryResult<any>>;
+    variables: import("@apollo/client").OperationVariables | undefined;
     fetchMore: <TFetchData = any, TFetchVars = import("@apollo/client").OperationVariables>(fetchMoreOptions: import("@apollo/client").FetchMoreQueryOptions<TFetchVars, TFetchData> & {
         updateQuery?: ((previousQueryResult: any, options: {
             fetchMoreResult: TFetchData;

package/dist/watch/watch.cmd.d.ts

@@ -25,8 +25,8 @@ export declare class WatchCommand implements Command {
         onAll: (event: string, path: string) => void;
         onStart: () => void;
         onReady: (workspace: any, watchPathsSortByComponent: any, verbose: any) => void;
-        onChange: (filePaths: string[], buildResults: OnComponentEventResult[], verbose: boolean, duration: any, failureMsg?: string | undefined) => void;
-        onAdd: (filePaths: string[], buildResults: OnComponentEventResult[], verbose: boolean, duration: any, failureMsg?: string | undefined) => void;
+        onChange: (filePaths: string[], buildResults: OnComponentEventResult[], verbose: boolean, duration: any, failureMsg?: string) => void;
+        onAdd: (filePaths: string[], buildResults: OnComponentEventResult[], verbose: boolean, duration: any, failureMsg?: string) => void;
         onUnlink: (p: any) => void;
         onError: (err: any) => void;
     };

package/dist/workspace.d.ts

@@ -1,3 +1,4 @@
+import { Graph } from '@teambit/graph.cleargraph';
 import type { PubsubMain } from '@teambit/pubsub';
 import { IssuesList } from '@teambit/component-issues';
 import type { AspectLoaderMain, AspectDefinition } from '@teambit/aspect-loader';
@@ -11,8 +12,6 @@ import { Logger } from '@teambit/logger';
 import type { ScopeMain } from '@teambit/scope';
 import { RequireableComponent } from '@teambit/harmony.modules.requireable-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 { LaneId } from '@teambit/lane-id';
 import { Consumer } from '@teambit/legacy/dist/consumer';
@@ -226,7 +225,7 @@ export declare class Workspace implements ComponentFactory {
     getNewAndModifiedIds(): Promise<ComponentID[]>;
     newAndModified(): Promise<Component[]>;
     getLogs(id: ComponentID, shortHash?: boolean, startsFrom?: string): Promise<ComponentLog[]>;
-    getLegacyGraph(ids?: ComponentID[], shouldThrowOnMissingDep?: boolean): Promise<LegacyGraph>;
+    getGraph(ids?: ComponentID[], shouldThrowOnMissingDep?: boolean): Promise<Graph<Component, string>>;
     /**
      * given component ids, find their dependents in the workspace
      */
@@ -398,7 +397,7 @@ export declare class Workspace implements ComponentFactory {
      */
     getComponentIdByPath(componentPath: PathOsBased): Promise<ComponentID | undefined>;
     private componentConfigFileFromComponentDirAndName;
-    getAspectsGraphWithoutCore(components: Component[], isAspect?: ShouldLoadFunc): Promise<LegacyGraph>;
+    getAspectsGraphWithoutCore(components: Component[], isAspect?: ShouldLoadFunc): Promise<Graph<Component, string>>;
     /**
      * load aspects from the workspace and if not exists in the workspace, load from the scope.
      * keep in mind that the graph may have circles.
@@ -409,7 +408,7 @@ export declare class Workspace implements ComponentFactory {
      * returns one graph that includes all dependencies types. each edge has a label of the dependency
      * type. the nodes content is the Component object.
      */
-    buildOneGraphForComponents(ids: BitId[], ignoreIds?: BitIds, shouldLoadFunc?: ShouldLoadFunc, shouldThrowOnMissingDep?: boolean): Promise<LegacyGraph>;
+    buildOneGraphForComponents(ids: ComponentID[], ignoreIds?: string[], shouldLoadFunc?: ShouldLoadFunc, shouldThrowOnMissingDep?: boolean): Promise<Graph<Component, string>>;
     resolveAspects(runtimeName?: string, componentIds?: ComponentID[], opts?: ResolveAspectsOptions): Promise<AspectDefinition[]>;
     private groupIdsByWorkspaceAndScope;
     private groupComponentsByWorkspaceAndScope;

package/dist/workspace.js

@@ -584,11 +584,9 @@ class Workspace {
   async getLogs(id, shortHash = false, startsFrom) {
     return this.scope.getLogs(id, shortHash, startsFrom);
   }
-  async getLegacyGraph(ids, shouldThrowOnMissingDep = true) {
+  async getGraph(ids, shouldThrowOnMissingDep = true) {
     if (!ids || ids.length < 1) ids = await this.listIds();
-    const legacyIds = ids.map(id => id._legacy);
-    const legacyGraph = await this.buildOneGraphForComponents(legacyIds, undefined, undefined, shouldThrowOnMissingDep);
-    return legacyGraph;
+    return this.buildOneGraphForComponents(ids, undefined, undefined, shouldThrowOnMissingDep);
   }
 
   /**
@@ -1494,10 +1492,9 @@ the following envs are used in this workspace: ${availableEnvs.join(', ')}`);
     return componentConfigFile;
   }
   async getAspectsGraphWithoutCore(components, isAspect) {
-    const ids = components.map(component => component.id._legacy);
+    const ids = components.map(component => component.id);
     const coreAspectsStringIds = this.aspectLoader.getCoreAspectIds();
-    const coreAspectsComponentIds = coreAspectsStringIds.map(id => _legacyBitId().BitId.parse(id, true));
-    const coreAspectsBitIds = _bitId().BitIds.fromArray(coreAspectsComponentIds.map(id => id.changeScope(null)));
+    // const coreAspectsComponentIds = coreAspectsStringIds.map((id) => BitId.parse(id, true));
     // const aspectsIds = components.reduce((acc, curr) => {
     //   const currIds = curr.state.aspects.ids;
     //   acc = acc.concat(currIds);
@@ -1515,8 +1512,7 @@ the following envs are used in this workspace: ${availableEnvs.join(', ')}`);
     // We only want to load into the graph components which are aspects and not regular dependencies
     // This come to solve a circular loop when an env aspect use an aspect (as regular dep) and the aspect use the env aspect as its env
     // TODO: @gilad it causes many issues we need to find a better solution. removed for now.
-    const ignoredIds = coreAspectsBitIds.concat([]);
-    return this.buildOneGraphForComponents(ids, _bitId().BitIds.fromArray(ignoredIds), isAspect);
+    return this.buildOneGraphForComponents(ids, coreAspectsStringIds, isAspect);
   }
 
   /**
@@ -1536,8 +1532,7 @@ needed-for: ${neededFor || '<unknown>'}`);
     const idsWithoutCore = (0, _lodash().difference)(notLoadedIds, coreAspectsStringIds);
     const componentIds = await this.resolveMultipleComponentIds(idsWithoutCore);
     const components = await this.importAndGetAspects(componentIds);
-    const isAspect = async bitId => {
-      const id = await this.resolveComponentId(bitId);
+    const isAspect = async id => {
       const component = await this.get(id);
       const data = this.envs.getEnvData(component);
       const isUsingAspectEnv = this.envs.isUsingAspectEnv(component);
@@ -1557,10 +1552,8 @@ needed-for: ${neededFor || '<unknown>'}`);
       return isValidAspect;
     };
     const graph = await this.getAspectsGraphWithoutCore(components, isAspect);
-    const idsStr = graph.nodes();
-    this.logger.debug(`${loggerPrefix} found ${idsStr.length} aspects in the aspects-graph`);
-    const compIds = await this.resolveMultipleComponentIds(idsStr);
-    const aspects = await this.getMany(compIds);
+    const aspects = graph.nodes.map(node => node.attr);
+    this.logger.debug(`${loggerPrefix} found ${aspects.length} aspects in the aspects-graph`);
     const {
       workspaceComps,
       scopeComps