@teambit/workspace 0.0.1065 → 0.0.1067

package/dist/{preview-1685272045621.js → preview-1685418569798.js}

@@ -1,5 +1,5 @@
-import * as compositions_0 from '/home/circleci/Library/Caches/Bit/capsules/8891be5ad3d35bfc38b9cd90c0e05b598a5a55af/teambit.workspace_workspace@0.0.1065/dist/workspace.composition.js';
-import * as overview_0 from '/home/circleci/Library/Caches/Bit/capsules/8891be5ad3d35bfc38b9cd90c0e05b598a5a55af/teambit.workspace_workspace@0.0.1065/dist/workspace.docs.mdx';
+import * as compositions_0 from '/home/circleci/Library/Caches/Bit/capsules/8891be5ad3d35bfc38b9cd90c0e05b598a5a55af/teambit.workspace_workspace@0.0.1067/dist/workspace.composition.js';
+import * as overview_0 from '/home/circleci/Library/Caches/Bit/capsules/8891be5ad3d35bfc38b9cd90c0e05b598a5a55af/teambit.workspace_workspace@0.0.1067/dist/workspace.docs.mdx';
 
 export const compositions = [compositions_0];
 export const overview = [overview_0];

package/dist/types.d.ts

@@ -39,6 +39,15 @@ export interface WorkspaceExtConfig {
      * from the scope aspects capsule.
      */
     resolveAspectsFromNodeModules?: boolean;
+    /**
+     * If set to `true`, it allows the workspace to resolve envs from node modules
+     * installed in the workspace's `node_modules` directory.
+     * the envs will be resolved from the node_modules of the env's root (workspace/node_modules/.bit_roots/{envId})
+     * and if not found (usually when the env was hoisted to the root node_modules) then from the node_modules of the
+     * workspace.
+     * If not set or set to `false`, envs will only be resolved from the scope envs capsule.
+     */
+    resolveEnvsFromRoots?: boolean;
     /**
      * If set to `true`, bit will try to load aspects dependencies automatically.
      * even if the aspects dependencies are not configured in the workspace.jsonc root config.

package/dist/types.js.map

@@ -1 +1 @@
-{"version":3,"names":[],"sources":["types.ts"],"sourcesContent":["interface VendorConfig {\n  directory: string;\n}\n\nexport interface WorkspaceExtConfig {\n  /**\n   * name of the workspace.\n   */\n  name: string;\n\n  /**\n   * path to icon.\n   */\n  icon: string;\n\n  /**\n   * applies only on bit.dev. configure the main owner of your workspace\n   */\n  defaultOwner: string;\n\n  /**\n   * set the default scope when there is no matching for the component in the components array.\n   */\n  defaultScope: string;\n\n  /**\n   * set the default directory when there is no matching for the component in the components array.\n   */\n  defaultDirectory: string;\n\n  /**\n   * set the default structure of components in your project\n   */\n  vendor: VendorConfig;\n\n  /**\n   * All component extensions applied by default on all components in the workspace (except vendor components)\n   */\n  extensions: { [extensionsId: string]: string };\n\n  /**\n   * If set to\n   * `true`, it allows the workspace to resolve scope's aspects from node modules\n   * installed in the workspace's `node_modules` directory. If not set or set to `false`, aspects will only be resolved\n   * from the scope aspects capsule.\n   */\n  resolveAspectsFromNodeModules?: boolean;\n\n  /**\n   * If set to `true`, bit will try to load aspects dependencies automatically.\n   * even if the aspects dependencies are not configured in the workspace.jsonc root config.\n   * for example having the aspect\n   * main aspect\n   * export class MainAspectMain {\n   *  ...\n   *   static dependencies = [MyDepAspect];\n   * }\n   * and the in the workspace.jsonc file:\n   * {\n   *  ...\n   *   main-aspect: {}\n   * }\n   * when set to true, bit will try to load MyDepAspect automatically.\n   */\n  autoLoadAspectsDeps?: boolean;\n}\n"],"mappings":""}
+{"version":3,"names":[],"sources":["types.ts"],"sourcesContent":["interface VendorConfig {\n  directory: string;\n}\n\nexport interface WorkspaceExtConfig {\n  /**\n   * name of the workspace.\n   */\n  name: string;\n\n  /**\n   * path to icon.\n   */\n  icon: string;\n\n  /**\n   * applies only on bit.dev. configure the main owner of your workspace\n   */\n  defaultOwner: string;\n\n  /**\n   * set the default scope when there is no matching for the component in the components array.\n   */\n  defaultScope: string;\n\n  /**\n   * set the default directory when there is no matching for the component in the components array.\n   */\n  defaultDirectory: string;\n\n  /**\n   * set the default structure of components in your project\n   */\n  vendor: VendorConfig;\n\n  /**\n   * All component extensions applied by default on all components in the workspace (except vendor components)\n   */\n  extensions: { [extensionsId: string]: string };\n\n  /**\n   * If set to\n   * `true`, it allows the workspace to resolve scope's aspects from node modules\n   * installed in the workspace's `node_modules` directory. If not set or set to `false`, aspects will only be resolved\n   * from the scope aspects capsule.\n   */\n  resolveAspectsFromNodeModules?: boolean;\n\n  /**\n   * If set to `true`, it allows the workspace to resolve envs from node modules\n   * installed in the workspace's `node_modules` directory.\n   * the envs will be resolved from the node_modules of the env's root (workspace/node_modules/.bit_roots/{envId})\n   * and if not found (usually when the env was hoisted to the root node_modules) then from the node_modules of the\n   * workspace.\n   * If not set or set to `false`, envs will only be resolved from the scope envs capsule.\n   */\n  resolveEnvsFromRoots?: boolean;\n\n  /**\n   * If set to `true`, bit will try to load aspects dependencies automatically.\n   * even if the aspects dependencies are not configured in the workspace.jsonc root config.\n   * for example having the aspect\n   * main aspect\n   * export class MainAspectMain {\n   *  ...\n   *   static dependencies = [MyDepAspect];\n   * }\n   * and the in the workspace.jsonc file:\n   * {\n   *  ...\n   *   main-aspect: {}\n   * }\n   * when set to true, bit will try to load MyDepAspect automatically.\n   */\n  autoLoadAspectsDeps?: boolean;\n}\n"],"mappings":""}

package/dist/workspace-aspects-loader.d.ts

@@ -15,6 +15,7 @@ export declare type WorkspaceLoadAspectsOptions = LoadAspectsOptions & {
     useScopeAspectsCapsule?: boolean;
     runSubscribers?: boolean;
     skipDeps?: boolean;
+    resolveEnvsFromRoots?: boolean;
 };
 export declare type AspectPackage = {
     packageName: string;
@@ -31,14 +32,16 @@ export declare class WorkspaceAspectsLoader {
     private onAspectsResolveSlot;
     private onRootAspectAddedSlot;
     private resolveAspectsFromNodeModules;
+    private resolveEnvsFromRoots;
     private consumer;
     private resolvedInstalledAspects;
-    constructor(workspace: Workspace, scope: ScopeMain, aspectLoader: AspectLoaderMain, envs: EnvsMain, dependencyResolver: DependencyResolverMain, logger: Logger, harmony: Harmony, onAspectsResolveSlot: OnAspectsResolveSlot, onRootAspectAddedSlot: OnRootAspectAddedSlot, resolveAspectsFromNodeModules?: boolean);
+    constructor(workspace: Workspace, scope: ScopeMain, aspectLoader: AspectLoaderMain, envs: EnvsMain, dependencyResolver: DependencyResolverMain, logger: Logger, harmony: Harmony, onAspectsResolveSlot: OnAspectsResolveSlot, onRootAspectAddedSlot: OnRootAspectAddedSlot, resolveAspectsFromNodeModules?: boolean, resolveEnvsFromRoots?: boolean);
     /**
      * load aspects from the workspace and if not exists in the workspace, load from the node_modules.
      * keep in mind that the graph may have circles.
      */
     loadAspects(ids?: string[], throwOnError?: boolean, neededFor?: string, opts?: WorkspaceLoadAspectsOptions): Promise<string[]>;
+    private loadFromScopeAspectsCapsule;
     private loadAspectDefsByOrder;
     resolveAspects(runtimeName?: string, componentIds?: ComponentID[], opts?: ResolveAspectsOptions): Promise<AspectDefinition[]>;
     private logFoundWorkspaceVsScope;
@@ -100,6 +103,8 @@ export declare class WorkspaceAspectsLoader {
      * @returns
      */
     private groupComponentsByWorkspaceExistence;
+    private groupComponentsByLoadFromRootComps;
+    private shouldLoadFromRootComps;
     /**
      * split the provided components into 2 groups, one which are workspace components and the other which are not.
      * @param components

package/dist/workspace-aspects-loader.js

@@ -101,7 +101,7 @@ function _bitError() {
 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; }
 class WorkspaceAspectsLoader {
-  constructor(workspace, scope, aspectLoader, envs, dependencyResolver, logger, harmony, onAspectsResolveSlot, onRootAspectAddedSlot, resolveAspectsFromNodeModules = false) {
+  constructor(workspace, scope, aspectLoader, envs, dependencyResolver, logger, harmony, onAspectsResolveSlot, onRootAspectAddedSlot, resolveAspectsFromNodeModules = false, resolveEnvsFromRoots = false) {
     this.workspace = workspace;
     this.scope = scope;
     this.aspectLoader = aspectLoader;
@@ -112,10 +112,13 @@ class WorkspaceAspectsLoader {
     this.onAspectsResolveSlot = onAspectsResolveSlot;
     this.onRootAspectAddedSlot = onRootAspectAddedSlot;
     this.resolveAspectsFromNodeModules = resolveAspectsFromNodeModules;
+    this.resolveEnvsFromRoots = resolveEnvsFromRoots;
     (0, _defineProperty2().default)(this, "consumer", void 0);
     (0, _defineProperty2().default)(this, "resolvedInstalledAspects", void 0);
     this.consumer = this.workspace.consumer;
     this.resolvedInstalledAspects = new Map();
+    // Only enable this when root components is enabled as well
+    this.resolveEnvsFromRoots = this.resolveEnvsFromRoots && this.dependencyResolver.hasRootComponents();
   }
 
   /**
@@ -130,7 +133,8 @@ class WorkspaceAspectsLoader {
       runSubscribers: true,
       skipDeps: false,
       hideMissingModuleError: !!this.workspace.inInstallContext,
-      ignoreErrors: false
+      ignoreErrors: false,
+      resolveEnvsFromRoots: this.resolveEnvsFromRoots
     };
     const mergedOpts = _objectSpread(_objectSpread({}, defaultOpts), opts);
 
@@ -148,7 +152,7 @@ needed-for: ${neededFor || '<unknown>'}. using opts: ${JSON.stringify(mergedOpts
     const {
       workspaceIds,
       nonWorkspaceIds
-    } = await this.groupIdsByWorkspaceExistence(componentIds);
+    } = await this.groupIdsByWorkspaceExistence(componentIds, mergedOpts.resolveEnvsFromRoots);
     this.logFoundWorkspaceVsScope(loggerPrefix, workspaceIds, nonWorkspaceIds);
     let idsToLoadFromWs = componentIds;
     let scopeAspectIds = [];
@@ -158,31 +162,11 @@ needed-for: ${neededFor || '<unknown>'}. using opts: ${JSON.stringify(mergedOpts
     // like for the cloud app
     // it should be removed once we fix the issues
     if (!this.resolveAspectsFromNodeModules) {
-      if (!this.resolveAspectsFromNodeModules) {
-        mergedOpts.useScopeAspectsCapsule = true;
-      }
+      mergedOpts.useScopeAspectsCapsule = true;
     }
     if (mergedOpts.useScopeAspectsCapsule) {
       idsToLoadFromWs = workspaceIds;
-      const currentLane = await this.consumer.getCurrentLaneObject();
-      const nonWorkspaceIdsString = nonWorkspaceIds.map(id => id.toString());
-      try {
-        scopeAspectIds = await this.scope.loadAspects(nonWorkspaceIdsString, throwOnError, neededFor, currentLane || undefined, {
-          packageManagerConfigRootDir: this.workspace.path,
-          workspaceName: this.workspace.name
-        });
-      } catch (err) {
-        if (err instanceof _exceptions().ComponentNotFound) {
-          var _config$workspaceConf;
-          const config = this.harmony.get('teambit.harmony/config');
-          const configStr = JSON.stringify(((_config$workspaceConf = config.workspaceConfig) === null || _config$workspaceConf === void 0 ? void 0 : _config$workspaceConf.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;
-      }
+      scopeAspectIds = await this.loadFromScopeAspectsCapsule(nonWorkspaceIds, throwOnError, neededFor);
     }
     const aspectsDefs = await this.resolveAspects(undefined, idsToLoadFromWs, _objectSpread({
       excludeCore: true,
@@ -210,6 +194,31 @@ needed-for: ${neededFor || '<unknown>'}. using opts: ${JSON.stringify(mergedOpts
     const manifestIds = manifests.map(manifest => manifest.id);
     return (0, _lodash().compact)(manifestIds.concat(scopeAspectIds));
   }
+  async loadFromScopeAspectsCapsule(ids, throwOnError, neededFor) {
+    let scopeAspectIds = [];
+    const currentLane = await this.consumer.getCurrentLaneObject();
+    if (!ids.length) return [];
+    const nonWorkspaceIdsString = ids.map(id => id.toString());
+    try {
+      scopeAspectIds = await this.scope.loadAspects(nonWorkspaceIdsString, throwOnError, neededFor, currentLane || undefined, {
+        packageManagerConfigRootDir: this.workspace.path,
+        workspaceName: this.workspace.name
+      });
+      return scopeAspectIds;
+    } catch (err) {
+      if (err instanceof _exceptions().ComponentNotFound) {
+        var _config$workspaceConf;
+        const config = this.harmony.get('teambit.harmony/config');
+        const configStr = JSON.stringify(((_config$workspaceConf = config.workspaceConfig) === null || _config$workspaceConf === void 0 ? void 0 : _config$workspaceConf.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.`);
+        }
+        return scopeAspectIds;
+      }
+      throw err;
+    }
+  }
   async loadAspectDefsByOrder(aspectsDefs, seeders, throwOnError, hideMissingModuleError, neededFor, runSubscribers = true) {
     const {
       nonWorkspaceDefs
@@ -247,7 +256,8 @@ needed-for: ${neededFor || '<unknown>'}. using opts: ${JSON.stringify(mergedOpts
       requestedOnly: false,
       filterByRuntime: true,
       useScopeAspectsCapsule: false,
-      workspaceName: this.workspace.name
+      workspaceName: this.workspace.name,
+      resolveEnvsFromRoots: false
     };
     const mergedOpts = _objectSpread(_objectSpread({}, defaultOpts), opts);
     const idsToResolve = componentIds ? componentIds.map(id => id.toString()) : this.harmony.extensionsIds;
@@ -273,15 +283,18 @@ needed-for: ${neededFor || '<unknown>'}. using opts: ${JSON.stringify(mergedOpts
       const finalDefs = this.aspectLoader.filterAspectDefs(targetDefs, idsToFilter, runtimeName, mergedOpts);
       return finalDefs;
     }
-    const graph = await this.getAspectsGraphWithoutCore(components, this.isAspect.bind(this));
-    const aspects = graph.nodes.map(node => node.attr);
-    this.logger.debug(`${loggerPrefix} found ${aspects.length} aspects in the aspects-graph`);
+    const groupedByIsPlugin = (0, _lodash().groupBy)(components, component => {
+      return this.aspectLoader.hasPluginFiles(component);
+    });
+    const graph = await this.getAspectsGraphWithoutCore(groupedByIsPlugin.false, this.isAspect.bind(this));
+    const aspectsComponents = graph.nodes.map(node => node.attr).concat(groupedByIsPlugin.true || []);
+    this.logger.debug(`${loggerPrefix} found ${aspectsComponents.length} aspects in the aspects-graph`);
     const {
       workspaceComps,
       nonWorkspaceComps
-    } = await this.groupComponentsByWorkspaceExistence(aspects);
+    } = await this.groupComponentsByWorkspaceExistence(aspectsComponents, mergedOpts.resolveEnvsFromRoots);
     const workspaceCompsIds = workspaceComps.map(c => c.id);
-    const nonWorkspaceCompsIds = workspaceComps.map(c => c.id);
+    const nonWorkspaceCompsIds = nonWorkspaceComps.map(c => c.id);
     this.logFoundWorkspaceVsScope(loggerPrefix, workspaceCompsIds, nonWorkspaceCompsIds);
     const stringIds = [];
     const wsAspectDefs = await this.aspectLoader.resolveAspects(workspaceComps, this.getWorkspaceAspectResolver(stringIds, runtimeName));
@@ -542,7 +555,7 @@ needed-for: ${neededFor || '<unknown>'}. using opts: ${JSON.stringify(mergedOpts
    * @param isAspect
    * @returns
    */
-  async getAspectsGraphWithoutCore(components, isAspect) {
+  async getAspectsGraphWithoutCore(components = [], isAspect) {
     const ids = components.map(component => component.id);
     const coreAspectsStringIds = this.aspectLoader.getCoreAspectIds();
     // TODO: @gilad it causes many issues we need to find a better solution. removed for now.
@@ -582,7 +595,8 @@ needed-for: ${neededFor || '<unknown>'}. using opts: ${JSON.stringify(mergedOpts
     const defaultOpts = {
       useScopeAspectsCapsule: true,
       throwOnError: false,
-      hideMissingModuleError: !!this.workspace.inInstallContext
+      hideMissingModuleError: !!this.workspace.inInstallContext,
+      resolveEnvsFromRoots: this.resolveEnvsFromRoots
     };
     const mergedOpts = _objectSpread(_objectSpread({}, defaultOpts), opts);
     const extensionsIdsP = extensions.map(async extensionEntry => {
@@ -637,18 +651,63 @@ your workspace.jsonc has this component-id set. you might want to remove/change
    * @param components
    * @returns
    */
-  async groupComponentsByWorkspaceExistence(components) {
-    const workspaceComps = [];
-    const nonWorkspaceComps = [];
+  async groupComponentsByWorkspaceExistence(components, resolveEnvsFromRoots) {
+    let workspaceComps = [];
+    let nonWorkspaceComps = [];
     await Promise.all(components.map(async component => {
       const existOnWorkspace = await this.workspace.hasId(component.id);
       existOnWorkspace ? workspaceComps.push(component) : nonWorkspaceComps.push(component);
     }));
+    if (resolveEnvsFromRoots) {
+      const {
+        rootComps,
+        nonRootComps
+      } = await this.groupComponentsByLoadFromRootComps(nonWorkspaceComps);
+      workspaceComps = workspaceComps.concat(rootComps);
+      nonWorkspaceComps = nonRootComps;
+    }
     return {
       workspaceComps,
       nonWorkspaceComps
     };
   }
+  async groupComponentsByLoadFromRootComps(components) {
+    const rootComps = [];
+    const nonRootComps = [];
+    await Promise.all(components.map(async component => {
+      const shouldLoadFromRootComps = await this.shouldLoadFromRootComps(component);
+      if (shouldLoadFromRootComps) {
+        rootComps.push(component);
+        return;
+      }
+      nonRootComps.push(component);
+    }));
+    return {
+      rootComps,
+      nonRootComps
+    };
+  }
+  async shouldLoadFromRootComps(component) {
+    const rootDir = this.workspace.getComponentPackagePath(component);
+    const rootDirExist = await _fsExtra().default.pathExists(rootDir);
+    const aspectFilePath = await this.aspectLoader.getAspectFilePath(component, rootDir);
+    const aspectFilePathExist = aspectFilePath ? await _fsExtra().default.pathExists(aspectFilePath) : false;
+    const pluginFiles = await this.aspectLoader.getPluginFiles(component, rootDir);
+
+    // checking that we have the root dir (this means it's an aspect that needs to be loaded from there)
+    // and validate that localPathExist so we can
+    // really load the component from that path (if it's there it means that it's an env)
+    if (rootDirExist && (aspectFilePathExist || pluginFiles.length)) {
+      return true;
+    }
+    // If the component has env.jsonc we want to list it to be loaded from the root folder
+    // even if it's not there yet
+    // in that case we will fail to load it, and the user will need to run bit install
+    if (this.envs.hasEnvManifest(component)) {
+      return true;
+    }
+    return false;
+  }
 
   /**
    * split the provided components into 2 groups, one which are workspace components and the other which are not.
@@ -662,20 +721,37 @@ your workspace.jsonc has this component-id set. you might want to remove/change
       var _aspectDef$component;
       const id = (_aspectDef$component = aspectDef.component) === null || _aspectDef$component === void 0 ? void 0 : _aspectDef$component.id;
       const existOnWorkspace = id ? await this.workspace.hasId(id) : true;
-      existOnWorkspace ? workspaceDefs.push(aspectDef) : nonWorkspaceDefs.push(aspectDef);
+      if (existOnWorkspace) {
+        workspaceDefs.push(aspectDef);
+        return;
+      }
+      const shouldLoadFromRootComps = aspectDef.component ? await this.shouldLoadFromRootComps(aspectDef.component) : undefined;
+      if (shouldLoadFromRootComps) {
+        workspaceDefs.push(aspectDef);
+        return;
+      }
+      nonWorkspaceDefs.push(aspectDef);
     }));
     return {
       workspaceDefs,
       nonWorkspaceDefs
     };
   }
-  async groupIdsByWorkspaceExistence(ids) {
-    const workspaceIds = [];
-    const nonWorkspaceIds = [];
+  async groupIdsByWorkspaceExistence(ids, resolveEnvsFromRoots) {
+    let workspaceIds = [];
+    let nonWorkspaceIds = [];
     await Promise.all(ids.map(async id => {
       const existOnWorkspace = await this.workspace.hasId(id);
       existOnWorkspace ? workspaceIds.push(id) : nonWorkspaceIds.push(id);
     }));
+    // We need to bring the components in order to really group them with taking the root comps into account
+    const scopeComponents = await this.importAndGetAspects(nonWorkspaceIds);
+    const {
+      nonWorkspaceComps,
+      workspaceComps
+    } = await this.groupComponentsByWorkspaceExistence(scopeComponents, resolveEnvsFromRoots);
+    workspaceIds = workspaceIds.concat(workspaceComps.map(c => c.id));
+    nonWorkspaceIds = nonWorkspaceComps.map(c => c.id);
     return {
       workspaceIds,
       nonWorkspaceIds