@teambit/dependencies 1.0.106 → 1.0.108

package/dependencies.main.runtime.ts

@@ -0,0 +1,387 @@
+import { CLIAspect, CLIMain, MainRuntime } from '@teambit/cli';
+import moment from 'moment';
+import { ComponentID } from '@teambit/component-id';
+import {
+  DependencyResolverAspect,
+  DependencyResolverMain,
+  KEY_NAME_BY_LIFECYCLE_TYPE,
+} from '@teambit/dependency-resolver';
+import WorkspaceAspect, { OutsideWorkspaceError, Workspace } from '@teambit/workspace';
+import { cloneDeep, compact, set } from 'lodash';
+import pMapSeries from 'p-map-series';
+import ConsumerComponent from '@teambit/legacy/dist/consumer/component';
+import ComponentLoader, { DependencyLoaderOpts } from '@teambit/legacy/dist/consumer/component/component-loader';
+import DependencyGraph from '@teambit/legacy/dist/scope/graph/scope-graph';
+import DevFilesAspect, { DevFilesMain } from '@teambit/dev-files';
+import AspectLoaderAspect, { AspectLoaderMain } from '@teambit/aspect-loader';
+import { DependenciesLoader } from './dependencies-loader/dependencies-loader';
+import { DependenciesData, OverridesDependenciesData } from './dependencies-loader/dependencies-data';
+import {
+  DependenciesBlameCmd,
+  DependenciesCmd,
+  DependenciesDebugCmd,
+  DependenciesEjectCmd,
+  DependenciesGetCmd,
+  DependenciesRemoveCmd,
+  DependenciesResetCmd,
+  DependenciesSetCmd,
+  DependenciesUnsetCmd,
+  DependenciesUsageCmd,
+  RemoveDependenciesFlags,
+  SetDependenciesFlags,
+  WhyCmd,
+} from './dependencies-cmd';
+import { DependenciesAspect } from './dependencies.aspect';
+import { DebugDependencies } from './dependencies-loader/auto-detect-deps';
+
+export type RemoveDependencyResult = { id: ComponentID; removedPackages: string[] };
+
+export type DependenciesResultsDebug = DebugDependencies &
+  OverridesDependenciesData & { coreAspects: string[]; sources: { id: string; source: string }[] };
+
+export type DependenciesResults = {
+  scopeGraph: DependencyGraph;
+  workspaceGraph: DependencyGraph;
+  id: ComponentID;
+};
+
+export type BlameResult = {
+  snap: string;
+  tag?: string;
+  author: string;
+  date: string;
+  message: string;
+  version: string;
+};
+
+export class DependenciesMain {
+  constructor(
+    private workspace: Workspace,
+    private dependencyResolver: DependencyResolverMain,
+    private devFiles: DevFilesMain,
+    private aspectLoader: AspectLoaderMain
+  ) {}
+
+  async setDependency(
+    componentPattern: string,
+    packages: string[],
+    options: SetDependenciesFlags
+  ): Promise<{ changedComps: string[]; addedPackages: Record<string, string> }> {
+    const compIds = await this.workspace.idsByPattern(componentPattern);
+    const getDepField = () => {
+      if (options.dev) return 'devDependencies';
+      if (options.peer) return 'peerDependencies';
+      return 'dependencies';
+    };
+    const packagesObj = {};
+    await Promise.all(
+      packages.map(async (pkg) => {
+        const [name, version] = await this.getPackageNameAndVerResolved(pkg);
+        if (options.optional) {
+          packagesObj[name] = { optional: true, version };
+        } else {
+          packagesObj[name] = version;
+        }
+      })
+    );
+    const config = {
+      policy: {
+        [getDepField()]: packagesObj,
+      },
+    };
+    await Promise.all(
+      compIds.map(async (compId) => {
+        await this.workspace.addSpecificComponentConfig(compId, DependencyResolverAspect.id, config, {
+          shouldMergeWithExisting: true,
+          shouldMergeWithPrevious: true,
+        });
+      })
+    );
+
+    await this.workspace.bitMap.write(`deps-set (${componentPattern})`);
+
+    return {
+      changedComps: compIds.map((compId) => compId.toStringWithoutVersion()),
+      addedPackages: packagesObj,
+    };
+  }
+
+  async removeDependency(
+    componentPattern: string,
+    packages: string[],
+    options: RemoveDependenciesFlags = {},
+    removeOnlyIfExists = false // unset
+  ): Promise<RemoveDependencyResult[]> {
+    const compIds = await this.workspace.idsByPattern(componentPattern);
+    const results = await pMapSeries(compIds, async (compId) => {
+      const component = await this.workspace.get(compId);
+      const depList = await this.dependencyResolver.getDependencies(component);
+      const getCurrentConfig = async () => {
+        const currentConfigFromWorkspace = await this.workspace.getSpecificComponentConfig(
+          compId,
+          DependencyResolverAspect.id
+        );
+        if (currentConfigFromWorkspace) return currentConfigFromWorkspace;
+        const extFromScope = await this.workspace.getExtensionsFromScopeAndSpecific(compId);
+        return extFromScope?.toConfigObject()[DependencyResolverAspect.id];
+      };
+      const currentDepResolverConfig = await getCurrentConfig();
+      const newDepResolverConfig = cloneDeep(currentDepResolverConfig || {});
+      const removedPackagesWithNulls = await pMapSeries(packages, async (pkg) => {
+        const [name, version] = this.splitPkgToNameAndVer(pkg);
+        const dependency = depList.findByPkgNameOrCompId(name, version);
+        if (!dependency) return null;
+        const depName = dependency.getPackageName?.() || dependency.id;
+        const getLifeCycle = () => {
+          if (options.dev) return 'dev';
+          if (options.peer) return 'peer';
+          return dependency.lifecycle;
+        };
+        const depField = KEY_NAME_BY_LIFECYCLE_TYPE[getLifeCycle()];
+        const existsInSpecificConfig = newDepResolverConfig.policy?.[depField]?.[depName];
+        if (existsInSpecificConfig) {
+          if (existsInSpecificConfig === '-') return null;
+          delete newDepResolverConfig.policy[depField][depName];
+        } else {
+          if (removeOnlyIfExists) return null;
+          set(newDepResolverConfig, ['policy', depField, depName], '-');
+        }
+        return `${depName}@${dependency.version}`;
+      });
+      const removedPackages = compact(removedPackagesWithNulls);
+      if (!removedPackages.length) return null;
+      await this.workspace.addSpecificComponentConfig(compId, DependencyResolverAspect.id, newDepResolverConfig);
+      return { id: compId, removedPackages };
+    });
+    await this.workspace.bitMap.write(`deps-remove (${componentPattern})`);
+
+    return compact(results);
+  }
+
+  async reset(componentPattern: string): Promise<ComponentID[]> {
+    const compIds = await this.workspace.idsByPattern(componentPattern);
+    await pMapSeries(compIds, async (compId) => {
+      await this.workspace.addSpecificComponentConfig(compId, DependencyResolverAspect.id, { policy: {} });
+    });
+    await this.workspace.bitMap.write(`deps-reset (${componentPattern})`);
+
+    return compIds;
+  }
+
+  async eject(componentPattern: string): Promise<ComponentID[]> {
+    const compIds = await this.workspace.idsByPattern(componentPattern);
+    await pMapSeries(compIds, async (compId) => {
+      await this.workspace.addSpecificComponentConfig(
+        compId,
+        DependencyResolverAspect.id,
+        {},
+        {
+          shouldMergeWithExisting: true,
+          shouldMergeWithPrevious: true,
+        }
+      );
+    });
+    await this.workspace.bitMap.write(`deps-eject (${componentPattern})`);
+
+    return compIds;
+  }
+
+  async getDependencies(id: string): Promise<DependenciesResults> {
+    // @todo: supports this on bare-scope.
+    if (!this.workspace) throw new OutsideWorkspaceError();
+    const compId = await this.workspace.resolveComponentId(id);
+    const consumer = this.workspace.consumer;
+    const scopeGraph = await DependencyGraph.buildGraphFromScope(consumer.scope);
+    const scopeDependencyGraph = new DependencyGraph(scopeGraph);
+
+    const workspaceGraph = await DependencyGraph.buildGraphFromWorkspace(consumer, true);
+    const workspaceDependencyGraph = new DependencyGraph(workspaceGraph);
+
+    return { scopeGraph: scopeDependencyGraph, workspaceGraph: workspaceDependencyGraph, id: compId };
+  }
+
+  async loadDependencies(component: ConsumerComponent, opts: DependencyLoaderOpts) {
+    const dependenciesLoader = new DependenciesLoader(
+      component,
+      this.dependencyResolver,
+      this.devFiles,
+      this.aspectLoader
+    );
+    return dependenciesLoader.load(this.workspace, opts);
+  }
+
+  /**
+   * load dependencies without the need for the workspace.
+   * the "auto-detect" are passed here as "dependenciesData". the "overrides", such as dependencies from the env,
+   * are calculated here.
+   * eventually all these dependencies are added to the ConsumerComponent object.
+   */
+  async loadDependenciesFromScope(component: ConsumerComponent, dependenciesData: Partial<DependenciesData>) {
+    const dependenciesLoader = new DependenciesLoader(
+      component,
+      this.dependencyResolver,
+      this.devFiles,
+      this.aspectLoader
+    );
+    return dependenciesLoader.loadFromScope(dependenciesData);
+  }
+
+  async debugDependencies(id: string): Promise<DependenciesResultsDebug> {
+    // @todo: supports this on bare-scope.
+    if (!this.workspace) throw new OutsideWorkspaceError();
+    const compId = await this.workspace.resolveComponentId(id);
+    const component = await this.workspace.get(compId);
+    const consumerComponent = component.state._consumer as ConsumerComponent;
+
+    const dependenciesData = await this.loadDependencies(consumerComponent, {
+      cacheResolvedDependencies: {},
+      useDependenciesCache: false,
+    });
+
+    const { missingPackageDependencies, manuallyAddedDependencies, manuallyRemovedDependencies } =
+      dependenciesData.overridesDependencies;
+
+    const results = await this.dependencyResolver.getDependencies(component);
+    const sources = results.map((dep) => ({ id: dep.id, source: dep.source }));
+
+    return {
+      ...dependenciesData.debugDependenciesData,
+      manuallyRemovedDependencies,
+      manuallyAddedDependencies,
+      missingPackageDependencies,
+      coreAspects: dependenciesData.dependenciesData.coreAspects,
+      sources,
+    };
+  }
+
+  /**
+   * helps determine what snap/tag changed a specific dependency.
+   * the results are sorted from the oldest to newest.
+   */
+  async blame(compName: string, depName: string) {
+    const id = await this.workspace.resolveComponentId(compName);
+    const log = await this.workspace.scope.getLogs(id);
+    const blameResults: BlameResult[] = [];
+    let lastVersion = '';
+    await pMapSeries(log, async (logItem) => {
+      const component = await this.workspace.get(id.changeVersion(logItem.tag || logItem.hash));
+      const depList = await this.dependencyResolver.getDependencies(component);
+      const dependency = depList.findByPkgNameOrCompId(depName);
+      if (dependency && dependency.version === lastVersion) {
+        return;
+      }
+      let version: string;
+      if (!dependency) {
+        if (!lastVersion) return;
+        version = '<REMOVED>';
+      } else {
+        version = dependency.version;
+      }
+      if (!dependency || dependency.version === lastVersion) return;
+      lastVersion = dependency.version;
+      blameResults.push({
+        snap: logItem.hash,
+        tag: logItem.tag,
+        author: logItem.username || '<N/A>',
+        date: logItem.date ? moment(new Date(parseInt(logItem.date))).format('YYYY-MM-DD HH:mm:ss') : '<N/A>',
+        message: logItem.message,
+        version,
+      });
+    });
+    return blameResults;
+  }
+
+  async usageDeep(depName: string, opts?: { depth?: number }): Promise<string | undefined> {
+    if (!isComponentId(depName)) {
+      return this.dependencyResolver.getPackageManager()?.findUsages?.(depName, {
+        lockfileDir: this.workspace.path,
+        depth: opts?.depth,
+      });
+    }
+    return undefined;
+  }
+
+  /**
+   * @param depName either component-id-string or package-name (of the component or not component)
+   * @returns a map of component-id-string to the version of the dependency
+   */
+  async usage(depName: string): Promise<{ [compIdStr: string]: string }> {
+    const [name, version] = this.splitPkgToNameAndVer(depName);
+    const allComps = await this.workspace.list();
+    const results = {};
+    await Promise.all(
+      allComps.map(async (comp) => {
+        const depList = await this.dependencyResolver.getDependencies(comp);
+        const dependency = depList.findByPkgNameOrCompId(name, version);
+        if (dependency) {
+          results[comp.id.toString()] = dependency.version;
+        }
+      })
+    );
+    return results;
+  }
+
+  private async getPackageNameAndVerResolved(pkg: string): Promise<[string, string]> {
+    const resolveLatest = async (pkgName: string) => {
+      const versionResolver = await this.dependencyResolver.getVersionResolver({});
+      const resolved = await versionResolver.resolveRemoteVersion(pkgName, { rootDir: '' });
+      if (!resolved.version) throw new Error(`unable to resolve version for ${pkgName}`);
+      return resolved.version;
+    };
+    const [name, version] = this.splitPkgToNameAndVer(pkg);
+    const versionResolved = !version || version === 'latest' ? await resolveLatest(name) : version;
+    return [name, versionResolved];
+  }
+
+  private splitPkgToNameAndVer(pkg: string): [string, string | undefined] {
+    const packageSplit = pkg.split('@');
+    if (pkg.startsWith('@')) {
+      // scoped package
+      if (packageSplit.length > 3) throw new Error(`invalid package "${pkg}" syntax, expected "package[@version]"`);
+      return [`@${packageSplit[1]}`, packageSplit[2]];
+    }
+    if (packageSplit.length > 2) throw new Error(`invalid package "${pkg}" syntax, expected "package[@version]"`);
+    return [packageSplit[0], packageSplit[1]];
+  }
+
+  static slots = [];
+  static dependencies = [CLIAspect, WorkspaceAspect, DependencyResolverAspect, DevFilesAspect, AspectLoaderAspect];
+
+  static runtime = MainRuntime;
+
+  static async provider([cli, workspace, depsResolver, devFiles, aspectLoader]: [
+    CLIMain,
+    Workspace,
+    DependencyResolverMain,
+    DevFilesMain,
+    AspectLoaderMain
+  ]) {
+    const depsMain = new DependenciesMain(workspace, depsResolver, devFiles, aspectLoader);
+    const depsCmd = new DependenciesCmd();
+    depsCmd.commands = [
+      new DependenciesGetCmd(depsMain),
+      new DependenciesRemoveCmd(depsMain),
+      new DependenciesUnsetCmd(depsMain),
+      new DependenciesDebugCmd(depsMain),
+      new DependenciesSetCmd(depsMain),
+      new DependenciesResetCmd(depsMain),
+      new DependenciesEjectCmd(depsMain),
+      new DependenciesBlameCmd(depsMain),
+      new DependenciesUsageCmd(depsMain),
+    ];
+    const whyCmd = new WhyCmd(depsMain);
+    cli.register(depsCmd, whyCmd);
+
+    ComponentLoader.loadDeps = depsMain.loadDependencies.bind(depsMain);
+
+    return depsMain;
+  }
+}
+
+function isComponentId(depName: string) {
+  return depName.includes('/') && depName[0] !== '@';
+}
+
+DependenciesAspect.addRuntime(DependenciesMain);
+
+export default DependenciesMain;

package/dist/dependencies-cmd.d.ts

@@ -1,14 +1,14 @@
 import { Command, CommandOptions } from '@teambit/cli';
 import { DependenciesMain } from './dependencies.main.runtime';
-declare type GetDependenciesFlags = {
+type GetDependenciesFlags = {
     tree: boolean;
 };
-export declare type SetDependenciesFlags = {
+export type SetDependenciesFlags = {
     dev?: boolean;
     optional?: boolean;
     peer?: boolean;
 };
-export declare type RemoveDependenciesFlags = SetDependenciesFlags;
+export type RemoveDependenciesFlags = SetDependenciesFlags;
 export declare class DependenciesGetCmd implements Command {
     private deps;
     name: string;
@@ -121,7 +121,7 @@ export declare class DependenciesBlameCmd implements Command {
     constructor(deps: DependenciesMain);
     report([compName, depName]: [string, string]): Promise<string>;
 }
-declare type DependenciesUsageCmdOptions = {
+type DependenciesUsageCmdOptions = {
     depth?: number;
 };
 export declare class DependenciesUsageCmd implements Command {
@@ -145,7 +145,7 @@ export declare class DependenciesCmd implements Command {
     name: string;
     alias: string;
     description: string;
-    options: never[];
+    options: any[];
     group: string;
     commands: Command[];
     helpUrl: string;

package/dist/dependencies-loader/apply-overrides.d.ts

@@ -8,11 +8,11 @@ import Consumer from '@teambit/legacy/dist/consumer/consumer';
 import OverridesDependencies from './overrides-dependencies';
 import { DependenciesData } from './dependencies-data';
 import { DebugDependencies } from './auto-detect-deps';
-export declare type AllDependencies = {
+export type AllDependencies = {
     dependencies: Dependency[];
     devDependencies: Dependency[];
 };
-export declare type AllPackagesDependencies = {
+export type AllPackagesDependencies = {
     packageDependencies: Record<string, string>;
     devPackageDependencies: Record<string, string>;
     peerPackageDependencies: Record<string, string>;
@@ -36,7 +36,7 @@ export declare class ApplyOverrides {
     overridesDependencies: OverridesDependencies;
     debugDependenciesData: DebugDependencies;
     autoDetectOverrides: Record<string, any> | undefined;
-    constructor(component: Component, depsResolver: DependencyResolverMain, workspace?: Workspace | undefined);
+    constructor(component: Component, depsResolver: DependencyResolverMain, workspace?: Workspace);
     get consumer(): Consumer | undefined;
     getDependenciesData(): Promise<{
         dependenciesData: DependenciesData;

package/dist/dependencies-loader/apply-overrides.js

@@ -131,8 +131,7 @@ class ApplyOverrides {
     };
   }
   get consumer() {
-    var _this$workspace;
-    return (_this$workspace = this.workspace) === null || _this$workspace === void 0 ? void 0 : _this$workspace.consumer;
+    return this.workspace?.consumer;
   }
   async getDependenciesData() {
     await this.populateDependencies();
@@ -204,8 +203,7 @@ class ApplyOverrides {
     if (!missingIssue.data.length) this.issues.delete(_componentIssues().IssuesClasses.MissingPackagesDependenciesOnFs);
   }
   async loadAutoDetectOverrides() {
-    var _this$workspace2;
-    this.autoDetectOverrides = await ((_this$workspace2 = this.workspace) === null || _this$workspace2 === void 0 ? void 0 : _this$workspace2.getAutoDetectOverrides(this.component.extensions, this.component.id, this.component.files));
+    this.autoDetectOverrides = await this.workspace?.getAutoDetectOverrides(this.component.extensions, this.component.id, this.component.files);
   }
   cloneAllPackagesDependencies() {
     this.originAllPackagesDependencies = (0, _lodash().cloneDeep)(this.allPackagesDependencies);
@@ -235,8 +233,8 @@ class ApplyOverrides {
     if (field === 'peerDependencies') return undefined;
     const packageData = this._resolvePackageData(dependency);
     return {
-      componentId: packageData === null || packageData === void 0 ? void 0 : packageData.componentId,
-      packageName: packageData === null || packageData === void 0 ? void 0 : packageData.name
+      componentId: packageData?.componentId,
+      packageName: packageData?.name
     };
   }
   getDependenciesToAddManually(packageJson, existingDependencies) {
@@ -249,7 +247,7 @@ class ApplyOverrides {
       Object.keys(overrides[depField]).forEach(dependency => {
         const dependencyValue = overrides[depField][dependency];
         const componentData = this._getComponentIdToAdd(depField, dependency);
-        if (componentData !== null && componentData !== void 0 && componentData.componentId) {
+        if (componentData?.componentId) {
           const dependencyExist = existingDependencies[depField].find(d => d.id.isEqualWithoutVersion(componentData.componentId));
           if (!dependencyExist) {
             this.overridesDependencies._addManuallyAddedDep(depField, componentData.componentId.toString());
@@ -353,8 +351,7 @@ class ApplyOverrides {
           delete this.allPackagesDependencies[field][pkgName];
           peerDeps[pkgName] = peerVersionFromPkgJson;
         } else if (regularVersionFromPkgJson) {
-          var _this$allPackagesDepe;
-          (_this$allPackagesDepe = this.allPackagesDependencies.peerPackageDependencies) === null || _this$allPackagesDepe === void 0 || delete _this$allPackagesDepe[pkgName];
+          delete this.allPackagesDependencies.peerPackageDependencies?.[pkgName];
           this.allPackagesDependencies[field][pkgName] = regularVersionFromPkgJson;
         }
       }, this.allPackagesDependencies[field]);
@@ -377,8 +374,7 @@ class ApplyOverrides {
           delete this.allPackagesDependencies[field][pkgName];
           peerDeps[pkgName] = peerVersionFromWsPolicy;
         } else if (regularVersionFromWsPolicy) {
-          var _this$allPackagesDepe2;
-          (_this$allPackagesDepe2 = this.allPackagesDependencies.peerPackageDependencies) === null || _this$allPackagesDepe2 === void 0 || delete _this$allPackagesDepe2[pkgName];
+          delete this.allPackagesDependencies.peerPackageDependencies?.[pkgName];
           this.allPackagesDependencies[field][pkgName] = regularVersionFromWsPolicy;
         }
       }, this.allPackagesDependencies[field]);
@@ -405,7 +401,6 @@ class ApplyOverrides {
     }
   }
   async applyAutoDetectOverridesOnComponent() {
-    var _this$issues$getIssue;
     const autoDetectOverrides = this.autoDetectOverrides;
     if (!autoDetectOverrides || !Object.keys(autoDetectOverrides).length) {
       return;
@@ -413,7 +408,7 @@ class ApplyOverrides {
     const originallyExists = [];
     let missingPackages = [];
     // We want to also add missing packages to the peer list as we know to resolve the version from the env anyway
-    const missingData = (_this$issues$getIssue = this.issues.getIssueByName('MissingPackagesDependenciesOnFs')) === null || _this$issues$getIssue === void 0 ? void 0 : _this$issues$getIssue.data;
+    const missingData = this.issues.getIssueByName('MissingPackagesDependenciesOnFs')?.data;
     if (missingData) {
       missingPackages = (0, _lodash().uniq)(missingData.map(d => d.missingPackages).flat());
     }
@@ -506,8 +501,7 @@ class ApplyOverrides {
    * when it's authored.
    */
   _getPackageJson() {
-    var _this$consumer;
-    return (_this$consumer = this.consumer) === null || _this$consumer === void 0 ? void 0 : _this$consumer.packageJson.packageJsonObject;
+    return this.consumer?.packageJson.packageJsonObject;
   }
   _getPackageJsonFromComponentModel() {
     if (this.componentFromModel && this.component.componentMap) {