@teambit/workspace 0.0.918 → 0.0.919

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

@@ -0,0 +1,45 @@
+import { Graph } from '@teambit/graph.cleargraph';
+import { ComponentID } from '@teambit/component';
+import { ComponentDependency, DependencyResolverMain } from '@teambit/dependency-resolver';
+import { DepEdgeType } from '@teambit/graph';
+import { Logger } from '@teambit/logger';
+import { Workspace } from './workspace';
+export declare function lifecycleToDepType(compDep: ComponentDependency): DepEdgeType;
+export declare class GraphIdsFromFsBuilder {
+    private workspace;
+    private logger;
+    private dependencyResolver;
+    private shouldThrowOnMissingDep;
+    private graph;
+    private completed;
+    private depth;
+    private consumer;
+    private loadedComponents;
+    private importedIds;
+    constructor(workspace: Workspace, logger: Logger, dependencyResolver: DependencyResolverMain, shouldThrowOnMissingDep?: boolean);
+    /**
+     * 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.
+     */
+    buildGraph(ids: ComponentID[]): Promise<Graph<ComponentID, DepEdgeType>>;
+    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.
+     * once a component from scope is imported, we know that either we have its dependency graph or all flattened deps
+     */
+    private importObjects;
+    private processOneComponent;
+    /**
+     * 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,
+     * then ask the graph for all its successors. otherwise, if it's not there, fallback to load the deps components.
+     */
+    private processCompFromWorkspaceWithGraph;
+    private addDepEdge;
+    private loadManyComponents;
+}

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

@@ -0,0 +1,222 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+require("core-js/modules/es.array.iterator.js");
+require("core-js/modules/es.promise.js");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.GraphIdsFromFsBuilder = void 0;
+exports.lifecycleToDepType = lifecycleToDepType;
+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 _graph() {
+  const data = require("@teambit/graph.cleargraph");
+  _graph = 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 _exceptions() {
+  const data = require("@teambit/legacy/dist/scope/exceptions");
+  _exceptions = function () {
+    return data;
+  };
+  return data;
+}
+function _scope() {
+  const data = require("@teambit/scope");
+  _scope = function () {
+    return data;
+  };
+  return data;
+}
+function _lodash2() {
+  const data = _interopRequireDefault(require("lodash.compact"));
+  _lodash2 = function () {
+    return data;
+  };
+  return data;
+}
+function _bitError() {
+  const data = require("@teambit/bit-error");
+  _bitError = function () {
+    return data;
+  };
+  return data;
+}
+function lifecycleToDepType(compDep) {
+  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`);
+  }
+}
+class GraphIdsFromFsBuilder {
+  constructor(workspace, logger, dependencyResolver, shouldThrowOnMissingDep = true) {
+    this.workspace = workspace;
+    this.logger = logger;
+    this.dependencyResolver = dependencyResolver;
+    this.shouldThrowOnMissingDep = shouldThrowOnMissingDep;
+    (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, "loadedComponents", {});
+    (0, _defineProperty2().default)(this, "importedIds", []);
+    this.consumer = this.workspace.consumer;
+  }
+
+  /**
+   * 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) {
+    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;
+  }
+  async processManyComponents(components) {
+    this.logger.debug(`GraphIdsFromFsBuilder.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);
+  }
+
+  /**
+   * 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
+   */
+  async importObjects(components) {
+    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 withScope = notImported.map(id => id._legacy).filter(dep => dep.hasScope());
+    const scopeComponentsImporter = this.consumer.scope.scopeImporter;
+    await scopeComponentsImporter.importMany({
+      ids: _bitIds().default.uniqFromArray(withScope),
+      throwForDependencyNotFound: this.shouldThrowOnMissingDep,
+      throwForSeederNotFound: this.shouldThrowOnMissingDep,
+      reFetchUnBuiltVersion: false,
+      preferDependencyGraph: true
+    });
+    notImported.map(id => this.importedIds.push(id.toString()));
+  }
+  async processOneComponent(component) {
+    const idStr = component.id.toString();
+    if (this.completed.includes(idStr)) return [];
+    const graphFromScope = await this.workspace.getSavedGraphOfComponentIfExist(component);
+    if (graphFromScope !== null && graphFromScope !== void 0 && 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,
+   * then ask the graph for all its successors. otherwise, if it's not there, fallback to load the deps components.
+   */
+  async processCompFromWorkspaceWithGraph(graphFromScope, component) {
+    const deps = await this.dependencyResolver.getComponentDependencies(component);
+    const [depsInScopeGraph, depsNotInScopeGraph] = (0, _lodash().partition)(deps, dep => graphFromScope.hasNode(dep.componentId.toString()));
+    const subGraphs = depsInScopeGraph.map(dep => graphFromScope.successorsSubgraph([dep.componentId.toString()]));
+    this.graph.merge(subGraphs);
+    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;
+  }
+  addDepEdge(idStr, dep) {
+    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 (_graph().Edge)(idStr, depId.toString(), lifecycleToDepType(dep)));
+  }
+  async loadManyComponents(componentsIds, dependenciesOf) {
+    const components = await (0, _pMapSeries().default)(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 (_graph().Node)(idStr, component.id));
+        return component;
+      } catch (err) {
+        if (err instanceof _exceptions().ComponentNotFound || err instanceof _scope().ComponentNotFound || err instanceof _exceptions().ScopeNotFound) {
+          if (dependenciesOf && !this.shouldThrowOnMissingDep) {
+            this.logger.warn(`component ${idStr}, dependency of ${dependenciesOf} was not found. continuing without it`);
+            return null;
+          }
+          throw new (_bitError().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 (0, _lodash2().default)(components);
+  }
+}
+exports.GraphIdsFromFsBuilder = GraphIdsFromFsBuilder;
+
+//# sourceMappingURL=build-graph-ids-from-fs.js.map

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

@@ -0,0 +1 @@
+{"version":3,"names":["lifecycleToDepType","compDep","isExtension","lifecycle","Error","GraphIdsFromFsBuilder","constructor","workspace","logger","dependencyResolver","shouldThrowOnMissingDep","Graph","consumer","buildGraph","ids","debug","length","start","Date","now","components","loadManyComponents","processManyComponents","graph","depth","importObjects","allDependencies","mapSeries","component","processOneComponent","allDependenciesFlattened","flatten","workspaceIds","listIds","compOnWorkspaceOnly","filter","comp","find","id","isEqual","notImported","map","c","importedIds","includes","toString","withScope","_legacy","dep","hasScope","scopeComponentsImporter","scope","scopeImporter","importMany","BitIds","uniqFromArray","throwForDependencyNotFound","throwForSeederNotFound","reFetchUnBuiltVersion","preferDependencyGraph","push","idStr","completed","graphFromScope","getSavedGraphOfComponentIfExist","edges","isOnWorkspace","hasId","allDependenciesComps","processCompFromWorkspaceWithGraph","merge","deps","getComponentDependencies","allDepsIds","d","componentId","forEach","addDepEdge","depsInScopeGraph","depsNotInScopeGraph","partition","hasNode","subGraphs","successorsSubgraph","depId","warn","setEdge","Edge","componentsIds","dependenciesOf","fromCache","loadedComponents","get","setNode","Node","err","ComponentNotFound","ComponentNotFoundInScope","ScopeNotFound","BitError","error","compact"],"sources":["build-graph-ids-from-fs.ts"],"sourcesContent":["import mapSeries from 'p-map-series';\nimport { Graph, Node, Edge } from '@teambit/graph.cleargraph';\nimport { flatten, partition } 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 { ComponentDependency, DependencyResolverMain } from '@teambit/dependency-resolver';\nimport { CompIdGraph, DepEdgeType } from '@teambit/graph';\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 function lifecycleToDepType(compDep: ComponentDependency): DepEdgeType {\n  if (compDep.isExtension) return 'ext';\n  switch (compDep.lifecycle) {\n    case 'dev':\n      return 'dev';\n    case 'runtime':\n      return 'prod';\n    default:\n      throw new Error(`lifecycle ${compDep.lifecycle} is not support`);\n  }\n}\n\nexport class GraphIdsFromFsBuilder {\n  private graph = new Graph<ComponentID, DepEdgeType>();\n  private completed: string[] = [];\n  private depth = 1;\n  private consumer: Consumer;\n  private loadedComponents: { [idStr: string]: Component } = {};\n  private importedIds: string[] = [];\n  constructor(\n    private workspace: Workspace,\n    private logger: Logger,\n    private dependencyResolver: DependencyResolverMain,\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 component-ids and the edges has a label of the dependency type.\n   * to get some info about this the graph build take a look into build-graph-from-fs.buildGraph() docs.\n   */\n  async buildGraph(ids: ComponentID[]): Promise<Graph<ComponentID, DepEdgeType>> {\n    this.logger.debug(`GraphIdsFromFsBuilder, 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      `GraphIdsFromFsBuilder, buildGraph with ${ids.length} seeders completed (${(Date.now() - start) / 1000} sec)`\n    );\n    return this.graph;\n  }\n\n  private async processManyComponents(components: Component[]) {\n    this.logger.debug(\n      `GraphIdsFromFsBuilder.processManyComponents depth ${this.depth}, ${components.length} components`\n    );\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   * once a component from scope is imported, we know that either we have its dependency graph or all flattened deps\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 notImported = compOnWorkspaceOnly.map((c) => c.id).filter((id) => !this.importedIds.includes(id.toString()));\n    const withScope = notImported.map((id) => id._legacy).filter((dep) => dep.hasScope());\n    const scopeComponentsImporter = this.consumer.scope.scopeImporter;\n    await scopeComponentsImporter.importMany({\n      ids: BitIds.uniqFromArray(withScope),\n      throwForDependencyNotFound: this.shouldThrowOnMissingDep,\n      throwForSeederNotFound: this.shouldThrowOnMissingDep,\n      reFetchUnBuiltVersion: false,\n      preferDependencyGraph: true,\n    });\n    notImported.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 graphFromScope = await this.workspace.getSavedGraphOfComponentIfExist(component);\n    if (graphFromScope?.edges.length) {\n      const isOnWorkspace = await this.workspace.hasId(component.id);\n      if (isOnWorkspace) {\n        const allDependenciesComps = await this.processCompFromWorkspaceWithGraph(graphFromScope, component);\n        this.completed.push(idStr);\n        return allDependenciesComps;\n      }\n      this.graph.merge([graphFromScope]);\n      this.completed.push(idStr);\n      return [];\n    }\n\n    const deps = await this.dependencyResolver.getComponentDependencies(component);\n    const allDepsIds = deps.map((d) => d.componentId);\n    const allDependenciesComps = await this.loadManyComponents(allDepsIds, idStr);\n\n    deps.forEach((dep) => this.addDepEdge(idStr, dep));\n    this.completed.push(idStr);\n\n    return allDependenciesComps;\n  }\n\n  /**\n   * this is tricky.\n   * the component is in the workspace so it can be modified. dependencies can be added/removed/updated/downgraded.\n   * we have the graph-dependencies from the last snap, so we prefer to use it whenever possible for performance reasons.\n   * if we can't use it, we have to recursively load dependencies components and get the data from there.\n   * to maximize the performance, we iterate the direct dependencies, if we find a dep with the same id in the graph,\n   * then ask the graph for all its successors. otherwise, if it's not there, fallback to load the deps components.\n   */\n  private async processCompFromWorkspaceWithGraph(\n    graphFromScope: CompIdGraph,\n    component: Component\n  ): Promise<Component[]> {\n    const deps = await this.dependencyResolver.getComponentDependencies(component);\n    const [depsInScopeGraph, depsNotInScopeGraph] = partition(deps, (dep) =>\n      graphFromScope.hasNode(dep.componentId.toString())\n    );\n    const subGraphs = depsInScopeGraph.map((dep) => graphFromScope.successorsSubgraph([dep.componentId.toString()]));\n    this.graph.merge(subGraphs);\n\n    const allDepsIds = depsNotInScopeGraph.map((d) => d.componentId);\n    const idStr = component.id.toString();\n    const allDependenciesComps = await this.loadManyComponents(allDepsIds, idStr);\n    deps.forEach((dep) => this.addDepEdge(idStr, dep));\n    return allDependenciesComps;\n  }\n\n  private addDepEdge(idStr: string, dep: ComponentDependency) {\n    const depId = dep.componentId;\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(), lifecycleToDepType(dep)));\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 fromCache = this.loadedComponents[idStr];\n      if (fromCache) return fromCache;\n      try {\n        const component = await this.workspace.get(comp);\n        this.loadedComponents[idStr] = component;\n        this.graph.setNode(new Node(idStr, component.id));\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/workspace.d.ts

@@ -20,6 +20,7 @@ import type { AddActionResults, Warnings } from '@teambit/legacy/dist/consumer/c
 import ComponentsList from '@teambit/legacy/dist/consumer/component/components-list';
 import { ExtensionDataList } from '@teambit/legacy/dist/consumer/config/extension-data';
 import { PathOsBased, PathOsBasedRelative, PathOsBasedAbsolute } from '@teambit/legacy/dist/utils/path';
+import { CompIdGraph, DepEdgeType } from '@teambit/graph';
 import ConsumerComponent from '@teambit/legacy/dist/consumer/component';
 import type { ComponentLog } from '@teambit/legacy/dist/scope/models/model-component';
 import { CompilationInitiator } from '@teambit/compiler';
@@ -228,6 +229,8 @@ export declare class Workspace implements ComponentFactory {
     newAndModified(): Promise<Component[]>;
     getLogs(id: ComponentID, shortHash?: boolean, startsFrom?: string): Promise<ComponentLog[]>;
     getGraph(ids?: ComponentID[], shouldThrowOnMissingDep?: boolean): Promise<Graph<Component, string>>;
+    getGraphIds(ids?: ComponentID[], shouldThrowOnMissingDep?: boolean): Promise<CompIdGraph>;
+    getSavedGraphOfComponentIfExist(component: Component): Promise<Graph<ComponentID, DepEdgeType> | null>;
     /**
      * given component ids, find their dependents in the workspace
      */
@@ -413,7 +416,6 @@ export declare class Workspace implements ComponentFactory {
      */
     loadAspects(ids?: string[], throwOnError?: boolean, neededFor?: string): Promise<string[]>;
     /**
-     * Note - this gets called from Harmony only.
      * returns one graph that includes all dependencies types. each edge has a label of the dependency
      * type. the nodes content is the Component object.
      */

package/dist/workspace.js

@@ -32,6 +32,13 @@ function _pMapSeries() {
   };
   return data;
 }
+function _graph() {
+  const data = require("@teambit/graph.cleargraph");
+  _graph = function () {
+    return data;
+  };
+  return data;
+}
 function _aspectLoader() {
   const data = require("@teambit/aspect-loader");
   _aspectLoader = function () {
@@ -298,6 +305,13 @@ function _workspace() {
   };
   return data;
 }
+function _buildGraphIdsFromFs() {
+  const data = require("./build-graph-ids-from-fs");
+  _buildGraphIdsFromFs = function () {
+    return data;
+  };
+  return data;
+}
 function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
 function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { (0, _defineProperty2().default)(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
 const AspectSpecificField = '__specific';
@@ -586,6 +600,44 @@ class Workspace {
     if (!ids || ids.length < 1) ids = await this.listIds();
     return this.buildOneGraphForComponents(ids, undefined, undefined, shouldThrowOnMissingDep);
   }
+  async getGraphIds(ids, shouldThrowOnMissingDep = true) {
+    if (!ids || ids.length < 1) ids = await this.listIds();
+    const graphIdsFromFsBuilder = new (_buildGraphIdsFromFs().GraphIdsFromFsBuilder)(this, this.logger, this.dependencyResolver, shouldThrowOnMissingDep);
+    return graphIdsFromFsBuilder.buildGraph(ids);
+  }
+  async getSavedGraphOfComponentIfExist(component) {
+    let versionObj;
+    try {
+      versionObj = await this.scope.legacyScope.getVersionInstance(component.id._legacy);
+    } catch (err) {
+      return null;
+    }
+    const flattenedEdges = versionObj.flattenedEdges;
+    if (!flattenedEdges.length && versionObj.flattenedDependencies.length) {
+      // there are flattenedDependencies, so must be edges, if they're empty, it's because the component was tagged
+      // with a version < ~0.0.901, so this flattenedEdges wasn't exist.
+      return null;
+    }
+    const flattenedBitIdCompIdMap = {};
+    flattenedBitIdCompIdMap[component.id._legacy.toString()] = component.id;
+    await Promise.all(versionObj.flattenedDependencies.map(async bitId => {
+      flattenedBitIdCompIdMap[bitId.toString()] = await this.resolveComponentId(bitId);
+    }));
+    const getCompIdByIdStr = idStr => {
+      const compId = flattenedBitIdCompIdMap[idStr];
+      if (!compId) throw new Error(`id ${idStr} exists in flattenedEdges but not in flattened`);
+      return compId;
+    };
+    const nodes = Object.values(flattenedBitIdCompIdMap);
+    const edges = flattenedEdges.map(edge => _objectSpread(_objectSpread({}, edge), {}, {
+      source: getCompIdByIdStr(edge.source.toString()),
+      target: getCompIdByIdStr(edge.target.toString())
+    }));
+    const graph = new (_graph().Graph)();
+    nodes.forEach(node => graph.setNode(new (_graph().Node)(node.toString(), node)));
+    edges.forEach(edge => graph.setEdge(new (_graph().Edge)(edge.source.toString(), edge.target.toString(), edge.type)));
+    return graph;
+  }
 
   /**
    * given component ids, find their dependents in the workspace
@@ -1614,7 +1666,6 @@ needed-for: ${neededFor || '<unknown>'}`);
   }
 
   /**
-   * Note - this gets called from Harmony only.
    * returns one graph that includes all dependencies types. each edge has a label of the dependency
    * type. the nodes content is the Component object.
    */