@teambit/workspace 1.0.106 → 1.0.108

package/workspace-component/workspace-component-loader.ts

@@ -185,9 +185,10 @@ export class WorkspaceComponentLoader {
     const groupedByIsCoreEnvs = groupBy(allIds, (id) => {
       return this.envs.isCoreEnv(id.toStringWithoutVersion());
     });
-    await this.populateScopeAndExtensionsCache(groupedByIsCoreEnvs.false || [], workspaceScopeIdsMap);
+    const nonCoreEnvs = groupedByIsCoreEnvs.false || [];
+    await this.populateScopeAndExtensionsCache(nonCoreEnvs, workspaceScopeIdsMap);
     const allExtIds: Map<string, ComponentID> = new Map();
-    groupedByIsCoreEnvs.false.forEach((id) => {
+    nonCoreEnvs.forEach((id) => {
       const idStr = id.toString();
       const fromCache = this.componentsExtensionsCache.get(idStr);
       if (!fromCache || !fromCache.extensions) {
@@ -203,7 +204,7 @@ export class WorkspaceComponentLoader {
     await this.populateScopeAndExtensionsCache(allExtCompIds || [], workspaceScopeIdsMap);
 
     const allExtIdsStr = allExtCompIds.map((id) => id.toString());
-    const groupedByIsExtOfAnother = groupBy(groupedByIsCoreEnvs.false, (id) => {
+    const groupedByIsExtOfAnother = groupBy(nonCoreEnvs, (id) => {
       return allExtIdsStr.includes(id.toString());
     });
     const extIdsFromTheList = (groupedByIsExtOfAnother.true || []).map((id) => id.toString());
@@ -228,7 +229,7 @@ export class WorkspaceComponentLoader {
 
     const groupsToHandle = [
       // Always load first core envs
-      { ids: groupedByIsCoreEnvs.true || [], core: true, aspects: true, seeders: false },
+      { ids: groupedByIsCoreEnvs.true || [], core: true, aspects: true, seeders: true },
       { ids: extsNotFromTheList || [], core: false, aspects: true, seeders: false },
       ...layerdExtGroups,
       { ids: groupedByIsExtOfAnother.false || [], core: false, aspects: false, seeders: true },
@@ -281,20 +282,20 @@ export class WorkspaceComponentLoader {
     // We don't want to ignore version here, as we do want to load different extensions with same id but different versions here
     const mergedExtensions = ExtensionDataList.mergeConfigs(allExtensions, false);
     await this.workspace.loadComponentsExtensions(mergedExtensions);
-    const withAspects = await pMap(components, (component) => this.executeLoadSlot(component), {
+    let wsComponentsWithAspects = workspaceComponents;
+    // if (loadOpts.seeders) {
+    wsComponentsWithAspects = await pMap(workspaceComponents, (component) => this.executeLoadSlot(component), {
       concurrency: concurrentComponentsLimit(),
     });
+    await this.warnAboutMisconfiguredEnvs(wsComponentsWithAspects);
+    // }
+
+    const withAspects = wsComponentsWithAspects.concat(scopeComponents);
 
-    // const withAspects = await Promise.all(
-    //   components.map((component) => {
-    //     return this.executeLoadSlot(component);
-    //   })
-    // );
-    await this.warnAboutMisconfiguredEnvs(withAspects);
     // It's important to load the workspace components as aspects here
     // otherwise the envs from the workspace won't be loaded at time
     // so we will get wrong dependencies from component who uses envs from the workspace
-    if (loadOpts.loadSeedersAsAspects) {
+    if (loadOpts.loadSeedersAsAspects || (loadOpts.core && loadOpts.aspects)) {
       await this.loadCompsAsAspects(workspaceComponents.concat(scopeComponents), {
         loadApps: true,
         loadEnvs: true,
@@ -625,11 +626,19 @@ export class WorkspaceComponentLoader {
 
   clearComponentCache(id: ComponentID) {
     const idStr = id.toString();
-    for (const cacheKey of this.componentsCache.keys()) {
-      if (cacheKey === idStr || cacheKey.startsWith(`${idStr}:`)) {
-        this.componentsCache.delete(cacheKey);
+    const cachesToClear = [
+      this.componentsCache,
+      this.scopeComponentsCache,
+      this.componentsExtensionsCache,
+      this.componentLoadedSelfAsAspects,
+    ];
+    cachesToClear.forEach((cache) => {
+      for (const cacheKey of cache.keys()) {
+        if (cacheKey === idStr || cacheKey.startsWith(`${idStr}:`)) {
+          cache.delete(cacheKey);
+        }
       }
-    }
+    });
   }
 
   private async loadOne(id: ComponentID, consumerComponent?: ConsumerComponent, loadOpts?: ComponentLoadOptions) {

package/workspace-section.ts

@@ -0,0 +1,14 @@
+// export class WorkspaceSection {
+//   constructor(
+//     readonly route: string
+//   ) {}
+
+//   toRoute() {
+//     return {
+//       path: this.toRoute
+//       children:
+//     };
+//   }
+// };
+
+// export interface WorkspaceSection {}

package/workspace.aspect.ts

@@ -0,0 +1,9 @@
+import { Aspect } from '@teambit/harmony';
+
+export const WorkspaceAspect = Aspect.create({
+  id: 'teambit.workspace/workspace',
+  dependencies: [],
+  defaultConfig: {},
+});
+
+export default WorkspaceAspect;

package/workspace.graphql.ts

@@ -0,0 +1,133 @@
+import { GraphqlMain } from '@teambit/graphql';
+import gql from 'graphql-tag';
+
+import { ComponentAdded, ComponentChanged, ComponentRemoved, Workspace } from './workspace';
+import { WorkspaceComponent } from './workspace-component';
+
+export default (workspace: Workspace, graphql: GraphqlMain) => {
+  return {
+    typeDefs: gql`
+      type ModifyInfo {
+        # is the component modified.
+        hasModifiedFiles: Boolean
+
+        # the component has Modified Dependencies
+        hasModifiedDependencies: Boolean
+      }
+
+      type ComponentStatus {
+        # component is pending to be tagged automatically.
+        modifyInfo: ModifyInfo
+
+        # is the new component new.
+        isNew: Boolean
+
+        # is the component deleted from the workspace.
+        isDeleted: Boolean
+
+        # is the component staged.
+        isStaged: Boolean
+
+        # does the component exists in the workspace.
+        isInWorkspace: Boolean
+
+        # does the component exists in the scope.
+        isInScope: Boolean
+
+        # does the component is outdated (pending for update).
+        isOutdated: Boolean
+      }
+
+      extend type Component {
+        status: ComponentStatus
+      }
+
+      type Issue {
+        type: String!
+        description: String!
+        solution: String
+        data: String
+      }
+
+      extend type Component {
+        # the count of errors in component in workspace
+        issuesCount: Int
+        issues: [Issue]
+      }
+
+      type Workspace {
+        name: String
+        path: String
+        icon: String
+        components(offset: Int, limit: Int): [Component]
+        getComponent(id: String!): Component
+      }
+
+      type Subscription {
+        componentAdded: ComponentAdded
+        componentChanged: ComponentChanged
+        componentRemoved: ComponentRemoved
+      }
+
+      type ComponentAdded {
+        component: Component
+      }
+
+      type ComponentChanged {
+        component: Component
+      }
+
+      type ComponentRemoved {
+        componentIds: [ComponentID]
+      }
+
+      type Query {
+        workspace: Workspace
+      }
+    `,
+    resolvers: {
+      Subscription: {
+        componentAdded: {
+          subscribe: () => graphql.pubsub.asyncIterator(ComponentAdded),
+        },
+        componentChanged: {
+          subscribe: () => graphql.pubsub.asyncIterator(ComponentChanged),
+        },
+        componentRemoved: {
+          subscribe: () => graphql.pubsub.asyncIterator(ComponentRemoved),
+        },
+      },
+      Component: {
+        status: async (wsComponent: WorkspaceComponent) => {
+          return wsComponent.getStatus();
+        },
+        issuesCount: (wsComponent: WorkspaceComponent): number => {
+          return wsComponent.getIssues()?.count || 0;
+        },
+        issues: (wsComponent: WorkspaceComponent) => {
+          return wsComponent.getIssues()?.toObjectWithDataAsString();
+        },
+      },
+      Workspace: {
+        path: (ws) => ws.path,
+        name: (ws) => ws.name,
+        icon: (ws) => ws.icon,
+        components: async (ws: Workspace, { offset, limit }: { offset: number; limit: number }) => {
+          return ws.list({ offset, limit });
+        },
+        getComponent: async (ws: Workspace, { id }: { id: string }) => {
+          try {
+            const componentID = await ws.resolveComponentId(id);
+            const component = await ws.get(componentID);
+            return component;
+          } catch (error: any) {
+            return null;
+          }
+        },
+      },
+      Query: {
+        workspace: () => workspace,
+      },
+    },
+  };
+};

package/workspace.main.runtime.ts

@@ -0,0 +1,56 @@
+import { PubsubAspect } from '@teambit/pubsub';
+import { AspectLoaderAspect } from '@teambit/aspect-loader';
+import { BundlerAspect } from '@teambit/bundler';
+import { CLIAspect, MainRuntime } from '@teambit/cli';
+import { ComponentAspect } from '@teambit/component';
+import { DependencyResolverAspect } from '@teambit/dependency-resolver';
+import { EnvsAspect } from '@teambit/envs';
+import { GraphqlAspect } from '@teambit/graphql';
+import { Slot } from '@teambit/harmony';
+import { IsolatorAspect } from '@teambit/isolator';
+import { LoggerAspect } from '@teambit/logger';
+import { ScopeAspect } from '@teambit/scope';
+import { UIAspect } from '@teambit/ui';
+import { VariantsAspect } from '@teambit/variants';
+import GlobalConfigAspect from '@teambit/global-config';
+
+import { EXT_NAME } from './constants';
+import { OnComponentAdd, OnComponentChange, OnComponentRemove, OnComponentLoad } from './on-component-events';
+import { WorkspaceAspect } from './workspace.aspect';
+import workspaceProvider, { OnAspectsResolve, OnBitmapChange, OnRootAspectAdded } from './workspace.provider';
+
+export const WorkspaceMain = {
+  name: EXT_NAME,
+  runtime: MainRuntime,
+  dependencies: [
+    PubsubAspect,
+    CLIAspect,
+    ScopeAspect,
+    ComponentAspect,
+    IsolatorAspect,
+    DependencyResolverAspect,
+    VariantsAspect,
+    LoggerAspect,
+    GraphqlAspect,
+    UIAspect,
+    BundlerAspect,
+    AspectLoaderAspect,
+    EnvsAspect,
+    GlobalConfigAspect,
+  ],
+  slots: [
+    Slot.withType<OnComponentLoad>(),
+    Slot.withType<OnComponentChange>(),
+    Slot.withType<OnComponentAdd>(),
+    Slot.withType<OnComponentRemove>(),
+    Slot.withType<OnAspectsResolve>(),
+    Slot.withType<OnRootAspectAdded>(),
+    Slot.withType<OnBitmapChange>(),
+  ],
+  provider: workspaceProvider,
+  defineRuntime: 'browser',
+};
+
+WorkspaceAspect.addRuntime(WorkspaceMain);
+
+export default WorkspaceMain;

package/workspace.provider.ts

@@ -0,0 +1,282 @@
+import { PubsubMain } from '@teambit/pubsub';
+import type { AspectLoaderMain } from '@teambit/aspect-loader';
+import { BundlerMain } from '@teambit/bundler';
+import { CLIMain, CommandList } from '@teambit/cli';
+import { DependencyResolverAspect, DependencyResolverMain } from '@teambit/dependency-resolver';
+import type { ComponentMain, Component } from '@teambit/component';
+import { EnvsMain } from '@teambit/envs';
+import { GraphqlMain } from '@teambit/graphql';
+import { Harmony, SlotRegistry } from '@teambit/harmony';
+import { IsolatorMain } from '@teambit/isolator';
+import { LoggerMain } from '@teambit/logger';
+import type { ScopeMain } from '@teambit/scope';
+import { UiMain } from '@teambit/ui';
+import type { VariantsMain } from '@teambit/variants';
+import { Consumer, loadConsumerIfExist } from '@teambit/legacy/dist/consumer';
+import ConsumerComponent from '@teambit/legacy/dist/consumer/component';
+import type { ComponentConfigLoadOptions } from '@teambit/legacy/dist/consumer/config';
+import { ExtensionDataList } from '@teambit/legacy/dist/consumer/config/extension-data';
+import LegacyComponentLoader, { ComponentLoadOptions } from '@teambit/legacy/dist/consumer/component/component-loader';
+import { ComponentID } from '@teambit/component-id';
+import { GlobalConfigMain } from '@teambit/global-config';
+import { EXT_NAME } from './constants';
+import EjectConfCmd from './eject-conf.cmd';
+import { OnComponentLoad, OnComponentAdd, OnComponentChange, OnComponentRemove } from './on-component-events';
+import { WorkspaceExtConfig } from './types';
+import { Workspace } from './workspace';
+import getWorkspaceSchema from './workspace.graphql';
+import { WorkspaceUIRoot } from './workspace.ui-root';
+import { CapsuleCmd, CapsuleCreateCmd, CapsuleDeleteCmd, CapsuleListCmd } from './capsule.cmd';
+import { EnvsSetCmd } from './envs-subcommands/envs-set.cmd';
+import { EnvsUnsetCmd } from './envs-subcommands/envs-unset.cmd';
+import { PatternCommand } from './pattern.cmd';
+import { EnvsReplaceCmd } from './envs-subcommands/envs-replace.cmd';
+import { ScopeSetCmd } from './scope-subcommands/scope-set.cmd';
+import { UseCmd } from './use.cmd';
+import { EnvsUpdateCmd } from './envs-subcommands/envs-update.cmd';
+
+export type WorkspaceDeps = [
+  PubsubMain,
+  CLIMain,
+  ScopeMain,
+  ComponentMain,
+  IsolatorMain,
+  DependencyResolverMain,
+  VariantsMain,
+  LoggerMain,
+  GraphqlMain,
+  UiMain,
+  BundlerMain,
+  AspectLoaderMain,
+  EnvsMain,
+  GlobalConfigMain
+];
+
+export type OnComponentLoadSlot = SlotRegistry<OnComponentLoad>;
+
+export type OnComponentChangeSlot = SlotRegistry<OnComponentChange>;
+
+export type OnComponentAddSlot = SlotRegistry<OnComponentAdd>;
+
+export type OnComponentRemoveSlot = SlotRegistry<OnComponentRemove>;
+
+export type OnBitmapChange = () => Promise<void>;
+export type OnBitmapChangeSlot = SlotRegistry<OnBitmapChange>;
+
+export type OnAspectsResolve = (aspectsComponents: Component[]) => Promise<void>;
+export type OnAspectsResolveSlot = SlotRegistry<OnAspectsResolve>;
+
+export type OnRootAspectAdded = (aspectsId: ComponentID, inWs: boolean) => Promise<void>;
+export type OnRootAspectAddedSlot = SlotRegistry<OnRootAspectAdded>;
+
+export default async function provideWorkspace(
+  [
+    pubsub,
+    cli,
+    scope,
+    component,
+    isolator,
+    dependencyResolver,
+    variants,
+    loggerExt,
+    graphql,
+    ui,
+    bundler,
+    aspectLoader,
+    envs,
+    globalConfig,
+  ]: WorkspaceDeps,
+  config: WorkspaceExtConfig,
+  [
+    onComponentLoadSlot,
+    onComponentChangeSlot,
+    onComponentAddSlot,
+    onComponentRemoveSlot,
+    onAspectsResolveSlot,
+    onRootAspectAddedSlot,
+    onBitmapChangeSlot,
+  ]: [
+    OnComponentLoadSlot,
+    OnComponentChangeSlot,
+    OnComponentAddSlot,
+    OnComponentRemoveSlot,
+    OnAspectsResolveSlot,
+    OnRootAspectAddedSlot,
+    OnBitmapChangeSlot
+  ],
+  harmony: Harmony
+) {
+  const bitConfig: any = harmony.config.get('teambit.harmony/bit');
+  const consumer = await getConsumer(bitConfig.cwd);
+  if (!consumer) {
+    const capsuleCmd = getCapsulesCommands(isolator, scope, undefined);
+    cli.register(capsuleCmd);
+    return undefined;
+  }
+  // TODO: get the 'workspace' name in a better way
+  const logger = loggerExt.createLogger(EXT_NAME);
+  const workspace = new Workspace(
+    pubsub,
+    config,
+    consumer,
+    scope,
+    component,
+    dependencyResolver,
+    variants,
+    aspectLoader,
+    logger,
+    undefined,
+    harmony,
+    onComponentLoadSlot,
+    onComponentChangeSlot,
+    envs,
+    globalConfig,
+    onComponentAddSlot,
+    onComponentRemoveSlot,
+    onAspectsResolveSlot,
+    onRootAspectAddedSlot,
+    graphql,
+    onBitmapChangeSlot
+  );
+
+  const configMergeFile = workspace.getConflictMergeFile();
+  await configMergeFile.loadIfNeeded();
+
+  const getWorkspacePolicyFromPackageJson = () => {
+    const packageJson = workspace.consumer.packageJson?.packageJsonObject || {};
+    const policyFromPackageJson = dependencyResolver.getWorkspacePolicyFromPackageJson(packageJson);
+    return policyFromPackageJson;
+  };
+
+  const getWorkspacePolicyFromMergeConfig = () => {
+    const wsConfigMerge = workspace.getWorkspaceJsonConflictFromMergeConfig();
+    const policy = wsConfigMerge.data?.[DependencyResolverAspect.id]?.policy || {};
+    ['dependencies', 'peerDependencies'].forEach((depField) => {
+      if (!policy[depField]) return;
+      policy[depField] = policy[depField].reduce((acc, current) => {
+        acc[current.name] = current.version;
+        return acc;
+      }, {});
+    });
+    const wsPolicy = dependencyResolver.getWorkspacePolicyFromConfigObject(policy);
+    return wsPolicy;
+  };
+
+  const getRootPolicy = () => {
+    const pkgJsonPolicy = getWorkspacePolicyFromPackageJson();
+    const configMergePolicy = getWorkspacePolicyFromMergeConfig();
+    return dependencyResolver.mergeWorkspacePolices([pkgJsonPolicy, configMergePolicy]);
+  };
+
+  dependencyResolver.registerRootPolicy(getRootPolicy());
+
+  consumer.onCacheClear.push(() => workspace.clearCache());
+
+  LegacyComponentLoader.registerOnComponentLoadSubscriber(
+    async (legacyComponent: ConsumerComponent, opts?: ComponentLoadOptions) => {
+      if (opts?.originatedFromHarmony) return legacyComponent;
+      const id = await workspace.resolveComponentId(legacyComponent.id);
+      const newComponent = await workspace.get(id, legacyComponent, true, true, opts);
+      return newComponent.state._consumer;
+    }
+  );
+
+  ConsumerComponent.registerOnComponentConfigLoading(EXT_NAME, async (id, loadOpts: ComponentConfigLoadOptions) => {
+    const componentId = await workspace.resolveComponentId(id);
+    // We call here directly workspace.scope.get instead of workspace.get because part of the workspace get is loading consumer component
+    // which in turn run this event, which will make an infinite loop
+    // This component from scope here are only used for merging the extensions with the workspace components
+    const componentFromScope = await workspace.scope.get(componentId);
+    const { extensions } = await workspace.componentExtensions(componentId, componentFromScope, undefined, loadOpts);
+    const defaultScope = await workspace.componentDefaultScope(componentId);
+
+    const extensionsWithLegacyIdsP = extensions.map(async (extension) => {
+      const legacyEntry = extension.clone();
+      if (legacyEntry.extensionId) {
+        legacyEntry.newExtensionId = legacyEntry.extensionId;
+      }
+
+      return legacyEntry;
+    });
+    const extensionsWithLegacyIds = await Promise.all(extensionsWithLegacyIdsP);
+
+    return {
+      defaultScope,
+      extensions: ExtensionDataList.fromArray(extensionsWithLegacyIds),
+    };
+  });
+
+  const workspaceSchema = getWorkspaceSchema(workspace, graphql);
+  ui.registerUiRoot(new WorkspaceUIRoot(workspace, bundler));
+  ui.registerPreStart(async () => {
+    return workspace.setComponentPathsRegExps();
+  });
+  graphql.register(workspaceSchema);
+  const capsuleCmd = getCapsulesCommands(isolator, scope, workspace);
+  const commands: CommandList = [new EjectConfCmd(workspace), capsuleCmd, new UseCmd(workspace)];
+
+  commands.push(new PatternCommand(workspace));
+  cli.register(...commands);
+  component.registerHost(workspace);
+
+  cli.registerOnStart(async (_hasWorkspace: boolean, currentCommand: string) => {
+    if (currentCommand === 'mini-status' || currentCommand === 'ms') {
+      return; // mini-status should be super fast.
+    }
+    if (currentCommand === 'install') {
+      workspace.inInstallContext = true;
+    }
+    await workspace.importCurrentLaneIfMissing();
+    const loadAspectsOpts = {
+      runSubscribers: false,
+      skipDeps: !config.autoLoadAspectsDeps,
+    };
+    const aspects = await workspace.loadAspects(
+      aspectLoader.getNotLoadedConfiguredExtensions(),
+      undefined,
+      'teambit.workspace/workspace (cli.registerOnStart)',
+      loadAspectsOpts
+    );
+    // clear aspect cache.
+    const componentIds = await workspace.resolveMultipleComponentIds(aspects);
+    componentIds.forEach((id) => {
+      workspace.clearComponentCache(id);
+    });
+  });
+
+  // add sub-commands "set" and "unset" to envs command.
+  const envsCommand = cli.getCommand('envs');
+  envsCommand?.commands?.push(new EnvsSetCmd(workspace)); // bit envs set
+  envsCommand?.commands?.push(new EnvsUnsetCmd(workspace)); // bit envs unset
+  envsCommand?.commands?.push(new EnvsReplaceCmd(workspace)); // bit envs replace
+  envsCommand?.commands?.push(new EnvsUpdateCmd(workspace)); // bit envs replace
+
+  // add sub-command "set" to scope command.
+  const scopeCommand = cli.getCommand('scope');
+  scopeCommand?.commands?.push(new ScopeSetCmd(workspace));
+
+  return workspace;
+}
+
+function getCapsulesCommands(isolator: IsolatorMain, scope: ScopeMain, workspace?: Workspace) {
+  const capsuleCmd = new CapsuleCmd(isolator, workspace, scope);
+  capsuleCmd.commands = [
+    new CapsuleListCmd(isolator, workspace, scope),
+    new CapsuleCreateCmd(workspace, scope, isolator),
+    new CapsuleDeleteCmd(isolator, scope, workspace),
+  ];
+  return capsuleCmd;
+}
+
+/**
+ * don't use loadConsumer() here, which throws ConsumerNotFound because some commands don't require
+ * the consumer to be available. such as, `bit init` or `bit list --remote`.
+ * most of the commands do need the consumer. the legacy commands that need the consumer throw an
+ * error when is missing. in the new/Harmony commands, such as `bis compile`, the workspace object
+ * is passed to the provider, so before using it, make sure it exists.
+ * keep in mind that you can't verify it in the provider itself, because the provider is running
+ * always for all commands before anything else is happening.
+ */
+async function getConsumer(path?: string): Promise<Consumer | undefined> {
+  return loadConsumerIfExist(path);
+}