@teambit/workspace 0.0.1002 → 0.0.1006

package/dist/workspace.js

@@ -39,20 +39,6 @@ function _graph() {
   };
   return data;
 }
-function _aspectLoader() {
-  const data = require("@teambit/aspect-loader");
-  _aspectLoader = function () {
-    return data;
-  };
-  return data;
-}
-function _cli() {
-  const data = require("@teambit/cli");
-  _cli = function () {
-    return data;
-  };
-  return data;
-}
 function _scopeGraph() {
   const data = _interopRequireDefault(require("@teambit/legacy/dist/scope/graph/scope-graph"));
   _scopeGraph = function () {
@@ -95,13 +81,6 @@ function _workspaceModules() {
   };
   return data;
 }
-function _harmonyModules() {
-  const data = require("@teambit/harmony.modules.requireable-component");
-  _harmonyModules = function () {
-    return data;
-  };
-  return data;
-}
 function _bitId() {
   const data = require("@teambit/legacy/dist/bit-id");
   _bitId = function () {
@@ -137,13 +116,6 @@ function _cacheFactory() {
   };
   return data;
 }
-function _exceptions() {
-  const data = require("@teambit/legacy/dist/scope/exceptions");
-  _exceptions = function () {
-    return data;
-  };
-  return data;
-}
 function _componentsList() {
   const data = _interopRequireDefault(require("@teambit/legacy/dist/consumer/component/components-list"));
   _componentsList = function () {
@@ -221,9 +193,9 @@ function _scopeComponentsImporter() {
   };
   return data;
 }
-function _exceptions2() {
+function _exceptions() {
   const data = require("@teambit/legacy/dist/consumer/bit-map/exceptions");
-  _exceptions2 = function () {
+  _exceptions = function () {
     return data;
   };
   return data;
@@ -249,13 +221,6 @@ function _scopeNotFoundOrDenied() {
   };
   return data;
 }
-function _workspaceModules2() {
-  const data = require("@teambit/workspace.modules.node-modules-linker");
-  _workspaceModules2 = function () {
-    return data;
-  };
-  return data;
-}
 function _componentVersion() {
   const data = require("@teambit/component-version");
   _componentVersion = function () {
@@ -319,6 +284,13 @@ function _aspectsMerger() {
   };
   return data;
 }
+function _workspaceAspectsLoader() {
+  const data = require("./workspace-aspects-loader");
+  _workspaceAspectsLoader = 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';
@@ -369,7 +341,7 @@ class Workspace {
   /**
    * on component add slot.
    */
-  onComponentAddSlot, onComponentRemoveSlot, graphql) {
+  onComponentAddSlot, onComponentRemoveSlot, onAspectsResolveSlot, onRootAspectAddedSlot, graphql) {
     var _this$config;
     this.pubsub = pubsub;
     this.config = config;
@@ -387,6 +359,8 @@ class Workspace {
     this.envs = envs;
     this.onComponentAddSlot = onComponentAddSlot;
     this.onComponentRemoveSlot = onComponentRemoveSlot;
+    this.onAspectsResolveSlot = onAspectsResolveSlot;
+    this.onRootAspectAddedSlot = onRootAspectAddedSlot;
     this.graphql = graphql;
     (0, _defineProperty2().default)(this, "priority", true);
     (0, _defineProperty2().default)(this, "owner", void 0);
@@ -452,6 +426,14 @@ class Workspace {
     this.onComponentRemoveSlot.register(onComponentRemoveFunc);
     return this;
   }
+  registerOnAspectsResolve(onAspectsResolveFunc) {
+    this.onAspectsResolveSlot.register(onAspectsResolveFunc);
+    return this;
+  }
+  registerOnRootAspectAdded(onRootAspectAddedFunc) {
+    this.onRootAspectAddedSlot.register(onRootAspectAddedFunc);
+    return this;
+  }
 
   /**
    * name of the workspace as configured in either `workspace.json`.
@@ -716,6 +698,10 @@ class Workspace {
     this.componentLoadedSelfAsAspects.set(component.id.toString(), false);
     return component;
   }
+  async getConfiguredUserAspectsPackages(options) {
+    const workspaceAspectsLoader = this.getWorkspaceAspectsLoader();
+    return workspaceAspectsLoader.getConfiguredUserAspectsPackages(options);
+  }
 
   // TODO: @gilad we should refactor this asap into to the envs aspect.
   async getEnvSystemDescriptor(component) {
@@ -822,6 +808,9 @@ class Workspace {
   getCurrentLaneId() {
     return this.consumer.getCurrentLaneId();
   }
+  async getCurrentLaneObject() {
+    return this.consumer.getCurrentLaneObject();
+  }
   isOnMain() {
     return this.consumer.isOnMain();
   }
@@ -930,7 +919,7 @@ class Workspace {
       // if it's not a pattern but just id, resolve it without multimatch to support specifying id without scope-name
       const id = await this.resolveComponentId(pattern);
       if (this.exists(id)) return [id];
-      if (throwForNoMatch) throw new (_exceptions2().MissingBitMapComponent)(pattern);
+      if (throwForNoMatch) throw new (_exceptions().MissingBitMapComponent)(pattern);
       return [];
     }
     const ids = await this.listIds();
@@ -1040,22 +1029,8 @@ the following envs are used in this workspace: ${availableEnvs.join(', ')}`);
     });
   }
   async use(aspectIdStr) {
-    const aspectId = await this.resolveComponentId(aspectIdStr);
-    let aspectIdToAdd = aspectId.toStringWithoutVersion();
-    if (!(await this.hasId(aspectId))) {
-      const loadedIds = await this.scope.loadAspects([aspectIdStr], true, 'bit use command');
-      if (loadedIds[0]) aspectIdToAdd = loadedIds[0];
-    }
-    const config = this.harmony.get('teambit.harmony/config').workspaceConfig;
-    if (!config) {
-      throw new Error(`use() unable to get the workspace config`);
-    }
-    config.setExtension(aspectIdToAdd, {}, {
-      overrideExisting: false,
-      ignoreVersion: false
-    });
-    await config.write();
-    return aspectIdToAdd;
+    const workspaceAspectsLoader = this.getWorkspaceAspectsLoader();
+    return workspaceAspectsLoader.use(aspectIdStr);
   }
   async write(component, rootPath) {
     await Promise.all(component.filesystem.files.map(async file => {
@@ -1311,108 +1286,14 @@ the following envs are used in this workspace: ${availableEnvs.join(', ')}`);
     }
     return componentConfigFile;
   }
-  async getAspectsGraphWithoutCore(components, isAspect) {
-    const ids = components.map(component => component.id);
-    const coreAspectsStringIds = this.aspectLoader.getCoreAspectIds();
-    // 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);
-    //   return acc;
-    // }, [] as any);
-    // const otherDependenciesMap = components.reduce((acc, curr) => {
-    //   // const currIds = curr.state.dependencies.dependencies.map(dep => dep.id.toString());
-    //   const currMap = curr.state.dependencies.getIdsMap();
-    //   Object.assign(acc, currMap);
-    //   return acc;
-    // }, {});
-
-    // const depsWhichAreNotAspects = difference(Object.keys(otherDependenciesMap), aspectsIds);
-    // const depsWhichAreNotAspectsBitIds = depsWhichAreNotAspects.map((strId) => otherDependenciesMap[strId]);
-    // 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.
-    return this.buildOneGraphForComponents(ids, coreAspectsStringIds, isAspect);
-  }
 
   /**
    * 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.
    */
   async loadAspects(ids = [], throwOnError = false, neededFor) {
-    // generate a random callId to be able to identify the call from the logs
-    const callId = Math.floor(Math.random() * 1000);
-    const loggerPrefix = `[${callId}] loadAspects,`;
-    this.logger.info(`${loggerPrefix} loading ${ids.length} aspects.
-ids: ${ids.join(', ')}
-needed-for: ${neededFor || '<unknown>'}`);
-    const notLoadedIds = ids.filter(id => !this.aspectLoader.isAspectLoaded(id));
-    if (!notLoadedIds.length) return [];
-    const coreAspectsStringIds = this.aspectLoader.getCoreAspectIds();
-    const idsWithoutCore = (0, _lodash().difference)(notLoadedIds, coreAspectsStringIds);
-    const componentIds = await this.resolveMultipleComponentIds(idsWithoutCore);
-    const components = await this.importAndGetAspects(componentIds);
-    const isAspect = async id => {
-      const component = await this.get(id);
-      const isUsingAspectEnv = this.envs.isUsingAspectEnv(component);
-      const isUsingEnvEnv = this.envs.isUsingEnvEnv(component);
-      const isValidAspect = isUsingAspectEnv || isUsingEnvEnv;
-      // if (!isValidAspect && idsWithoutCore.includes(component.id.toString())) {
-      //   const data = this.envs.getEnvData(component);
-      //   const err = new IncorrectEnvAspect(component.id.toString(), data.type, data.id);
-      //   if (data.id === DEFAULT_ENV) {
-      //     // when cloning a project, or when the node-modules dir is deleted, nothing works and all
-      //     // components are default to the DEFAULT_ENV, which is node-env. we must allow "bit
-      //     // install" to prepare the workspace and let the proper the envs to be loaded
-      //     this.logger.error(err.message);
-      //   } else {
-      //     throw err;
-      //   }
-      // }
-      return isValidAspect;
-    };
-    const graph = await this.getAspectsGraphWithoutCore(components, isAspect);
-    const aspects = graph.nodes.map(node => node.attr);
-    this.logger.debug(`${loggerPrefix} found ${aspects.length} aspects in the aspects-graph`);
-    const {
-      workspaceComps,
-      scopeComps
-    } = await this.groupComponentsByWorkspaceAndScope(aspects);
-    this.logger.debug(`${loggerPrefix} found ${workspaceComps.length} components in the workspace:\n${workspaceComps.map(c => c.id.toString()).join('\n')}`);
-    this.logger.debug(`${loggerPrefix} ${scopeComps.length} components are not in the workspace and are loaded from the scope:\n${scopeComps.map(c => c.id.toString()).join('\n')}`);
-    const scopeIds = scopeComps.map(aspect => aspect.id.toString());
-    const workspaceAspects = await this.requireComponents(workspaceComps);
-    const workspaceManifests = await this.aspectLoader.getManifestsFromRequireableExtensions(workspaceAspects, throwOnError);
-    const potentialPluginsIndexes = (0, _lodash().compact)(workspaceManifests.map((manifest, index) => {
-      if (this.aspectLoader.isValidAspect(manifest)) return undefined;
-      return index;
-    }));
-    const workspaceManifestsIds = (0, _lodash().compact)(workspaceManifests.map(m => m.id));
-    // We are grouping the scope aspects by whether they are envs of something of the list or not
-    // if yes, we want to load them first
-    // the rest we will load together with the workspace aspects
-    const scopeIdsGrouped = await this.scope.groupAspectIdsByEnvOfTheList(scopeIds);
-    const scopeEnvsManifestsIds = scopeIdsGrouped.envs && scopeIdsGrouped.envs.length ? await this.scope.loadAspects(scopeIdsGrouped.envs, throwOnError, 'workspace.loadAspects loading scope aspects') : [];
-    const currentLane = await this.consumer.getCurrentLaneObject();
-    const {
-      manifests: scopeOtherManifests
-    } = scopeIdsGrouped.other && scopeIdsGrouped.other.length ? await this.scope.getManifestsGraphRecursively(scopeIdsGrouped.other, (0, _lodash().compact)(workspaceManifestsIds), throwOnError, currentLane || undefined, {
-      packageManagerConfigRootDir: this.path
-    }) : {
-      manifests: []
-    };
-    const scopeOtherManifestsIds = (0, _lodash().compact)(scopeOtherManifests.map(m => m.id));
-    await this.aspectLoader.loadExtensionsByManifests([...scopeOtherManifests, ...workspaceManifests], throwOnError, idsWithoutCore);
-    // Try require components for potential plugins
-    const pluginsWorkspaceComps = potentialPluginsIndexes.map(index => {
-      return workspaceComps[index];
-    });
-    // Do the require again now that the plugins defs already registered
-    const pluginsWorkspaceAspects = await this.requireComponents(pluginsWorkspaceComps);
-    const pluginsWorkspaceManifests = await this.aspectLoader.getManifestsFromRequireableExtensions(pluginsWorkspaceAspects, throwOnError);
-    await this.aspectLoader.loadExtensionsByManifests(pluginsWorkspaceManifests, throwOnError);
-    this.logger.debug(`${loggerPrefix} finish loading aspects`);
-    return (0, _lodash().compact)(scopeEnvsManifestsIds.concat(scopeOtherManifestsIds).concat(workspaceManifestsIds));
+    const workspaceAspectsLoader = this.getWorkspaceAspectsLoader();
+    return workspaceAspectsLoader.loadAspects(ids, throwOnError, neededFor);
   }
 
   /**
@@ -1424,105 +1305,8 @@ needed-for: ${neededFor || '<unknown>'}`);
     return graphFromFsBuilder.buildGraph(ids);
   }
   async resolveAspects(runtimeName, componentIds, opts) {
-    this.logger.debug(`workspace resolveAspects, runtimeName: ${runtimeName}, componentIds: ${componentIds}`);
-    const defaultOpts = {
-      excludeCore: false,
-      requestedOnly: false,
-      filterByRuntime: true
-    };
-    const mergedOpts = _objectSpread(_objectSpread({}, defaultOpts), opts);
-    let missingPaths = false;
-    const bitIds = [];
-    const idsToResolve = componentIds ? componentIds.map(id => id.toString()) : this.harmony.extensionsIds;
-    const coreAspectsIds = this.aspectLoader.getCoreAspectIds();
-    const userAspectsIds = (0, _lodash().difference)(idsToResolve, coreAspectsIds);
-    const componentIdsToResolve = await this.resolveMultipleComponentIds(userAspectsIds);
-    const {
-      workspaceIds,
-      scopeIds
-    } = await this.groupIdsByWorkspaceAndScope(componentIdsToResolve);
-    const wsComponents = await this.getMany(workspaceIds);
-    const aspectDefs = await this.aspectLoader.resolveAspects(wsComponents, async component => {
-      const compStringId = component.id._legacy.toString();
-      bitIds.push(component.id._legacy);
-      const localPath = this.getComponentPackagePath(component);
-      const isExist = await _fsExtra().default.pathExists(localPath);
-      if (!isExist) {
-        missingPaths = true;
-      }
-      const runtimePath = runtimeName ? await this.aspectLoader.getRuntimePath(component, localPath, runtimeName) : null;
-      const aspectFilePath = await this.aspectLoader.getAspectFilePath(component, localPath);
-      this.logger.debug(`workspace resolveAspects, resolving id: ${compStringId}, localPath: ${localPath}, runtimePath: ${runtimePath}`);
-      return {
-        aspectPath: localPath,
-        aspectFilePath,
-        runtimePath
-      };
-    });
-    let scopeAspectDefs = [];
-    if (scopeIds.length) {
-      scopeAspectDefs = await this.scope.resolveAspects(runtimeName, scopeIds, mergedOpts);
-    }
-    let coreAspectDefs = await Promise.all(coreAspectsIds.map(async coreId => {
-      const rawDef = await (0, _aspectLoader().getAspectDef)(coreId, runtimeName);
-      return this.aspectLoader.loadDefinition(rawDef);
-    }));
-
-    // due to lack of workspace and scope runtimes. TODO: fix after adding them.
-    if (runtimeName && mergedOpts.filterByRuntime) {
-      coreAspectDefs = coreAspectDefs.filter(coreAspect => {
-        return coreAspect.runtimePath;
-      });
-    }
-    if (missingPaths) {
-      await (0, _workspaceModules2().linkToNodeModulesByIds)(this, bitIds);
-    }
-    const allDefs = aspectDefs.concat(coreAspectDefs).concat(scopeAspectDefs);
-    const ids = idsToResolve.map(idStr => _component().ComponentID.fromString(idStr).toStringWithoutVersion());
-    const afterExclusion = mergedOpts.excludeCore ? allDefs.filter(def => {
-      const isCore = coreAspectDefs.find(coreId => def.getId === coreId.getId);
-      const id = _component().ComponentID.fromString(def.getId || '');
-      const isTarget = ids.includes(id.toStringWithoutVersion());
-      if (isTarget) return true;
-      return !isCore;
-    }) : allDefs;
-    const uniqDefs = (0, _lodash().uniqBy)(afterExclusion, def => `${def.aspectPath}-${def.runtimePath}`);
-    let defs = uniqDefs;
-    if (runtimeName && mergedOpts.filterByRuntime) {
-      defs = defs.filter(def => def.runtimePath);
-    }
-    if (componentIds && componentIds.length && mergedOpts.requestedOnly) {
-      const componentIdsString = componentIds.map(id => id.toString());
-      defs = defs.filter(def => {
-        var _def$component;
-        return def.id && componentIdsString.includes(def.id) || def.component && componentIdsString.includes((_def$component = def.component) === null || _def$component === void 0 ? void 0 : _def$component.id.toString());
-      });
-    }
-    return defs;
-  }
-  async groupIdsByWorkspaceAndScope(ids) {
-    const workspaceIds = [];
-    const scopeIds = [];
-    await Promise.all(ids.map(async id => {
-      const existOnWorkspace = await this.hasId(id);
-      existOnWorkspace ? workspaceIds.push(id) : scopeIds.push(id);
-    }));
-    return {
-      workspaceIds,
-      scopeIds
-    };
-  }
-  async groupComponentsByWorkspaceAndScope(components) {
-    const workspaceComps = [];
-    const scopeComps = [];
-    await Promise.all(components.map(async component => {
-      const existOnWorkspace = await this.hasId(component.id);
-      existOnWorkspace ? workspaceComps.push(component) : scopeComps.push(component);
-    }));
-    return {
-      workspaceComps,
-      scopeComps
-    };
+    const workspaceAspectsLoader = this.getWorkspaceAspectsLoader();
+    return workspaceAspectsLoader.resolveAspects(runtimeName, componentIds, opts);
   }
 
   /**
@@ -1545,61 +1329,14 @@ needed-for: ${neededFor || '<unknown>'}`);
     }
     return cacheDir;
   }
-  async requireComponents(components) {
-    let missingPaths = false;
-    const bitIds = [];
-    const resolveP = components.map(async component => {
-      bitIds.push(component.id._legacy);
-      const localPath = this.getComponentPackagePath(component);
-      const isExist = await _fsExtra().default.pathExists(localPath);
-      if (!isExist) {
-        missingPaths = true;
-      }
-      const requireFunc = async () => {
-        const plugins = this.aspectLoader.getPlugins(component, localPath);
-        if (plugins.has()) {
-          return plugins.load(_cli().MainRuntime.name);
-        }
-
-        // eslint-disable-next-line global-require, import/no-dynamic-require
-        const aspect = require(localPath);
-        // require aspect runtimes
-        const runtimePath = await this.aspectLoader.getRuntimePath(component, localPath, _cli().MainRuntime.name);
-        // eslint-disable-next-line global-require, import/no-dynamic-require
-        if (runtimePath) require(runtimePath);
-        return aspect;
-      };
-      return new (_harmonyModules().RequireableComponent)(component, requireFunc);
-    });
-    const resolved = await Promise.all(resolveP);
-    // Make sure to link missing components
-    if (missingPaths) {
-      await (0, _workspaceModules2().linkToNodeModulesByIds)(this, bitIds);
-    }
-    return resolved;
+  getWorkspaceAspectsLoader() {
+    const workspaceAspectsLoader = new (_workspaceAspectsLoader().WorkspaceAspectsLoader)(this, this.scope, this.aspectLoader, this.envs, this.dependencyResolver, this.logger, this.harmony, this.onAspectsResolveSlot, this.onRootAspectAddedSlot);
+    return workspaceAspectsLoader;
   }
 
   /**
-   * same as `this.importAndGetMany()` with a specific error handling of ComponentNotFound
-   */
-  async importAndGetAspects(componentIds) {
-    try {
-      return await this.importAndGetMany(componentIds);
-    } catch (err) {
-      if (err instanceof _exceptions().ComponentNotFound) {
-        var _config$workspaceConf3;
-        const config = this.harmony.get('teambit.harmony/config');
-        const configStr = JSON.stringify(((_config$workspaceConf3 = config.workspaceConfig) === null || _config$workspaceConf3 === void 0 ? void 0 : _config$workspaceConf3.raw) || {});
-        if (configStr.includes(err.id)) {
-          throw new (_bitError().BitError)(`error: a component "${err.id}" was not found
-your workspace.jsonc has this component-id set. you might want to remove/change it.`);
-        }
-      }
-      throw err;
-    }
   }
-
-  /**
+   /**
    * this should be rarely in-use.
    * it's currently used by watch extension as a quick workaround to load .bitmap and the components
    */