@teambit/dependency-resolver 1.0.106 → 1.0.108

package/apply-updates.spec.ts

@@ -0,0 +1,215 @@
+import { ComponentID } from '@teambit/component';
+import { applyUpdates } from './apply-updates';
+
+describe('applyUpdates()', () => {
+  it('should apply updates on root dependencies', () => {
+    const { updatedWorkspacePolicyEntries } = applyUpdates(
+      [
+        {
+          name: 'lodash',
+          latestRange: '2.0.0',
+          source: 'rootPolicy',
+          targetField: 'dependencies' as const,
+        },
+        {
+          name: 'react-dom',
+          latestRange: '2.0.0',
+          source: 'rootPolicy',
+          targetField: 'peerDependencies' as const,
+        },
+      ],
+      {
+        variantPoliciesByPatterns: {},
+      }
+    );
+    // @ts-ignore
+    expect(updatedWorkspacePolicyEntries).toStrictEqual(
+      [
+        {
+          dependencyId: 'lodash',
+          value: {
+            version: '2.0.0',
+          },
+          lifecycleType: 'runtime',
+        },
+        {
+          dependencyId: 'react-dom',
+          value: {
+            version: '2.0.0',
+          },
+          lifecycleType: 'peer',
+        },
+      ],
+      // @ts-ignore
+      { updateExisting: true }
+    );
+  });
+  it('should apply updates on variant dependencies', () => {
+    const variantPoliciesByPatterns = {
+      variant1: {
+        dependencies: {
+          'variant1-runtime-dep1': { version: '1.0.0', resolveFromEnv: true },
+          'variant1-runtime-dep2': '1.0.0',
+        },
+        devDependencies: {
+          'variant1-dev-dep1': '1.0.0',
+          'variant1-dev-dep2': '1.0.0',
+        },
+        peerDependencies: {
+          'variant1-peer-dep1': '1.0.0',
+          'variant1-peer-dep2': '1.0.0',
+        },
+      },
+      variant2: {
+        dependencies: {
+          'variant2-runtime-dep1': '1.0.0',
+          'variant2-runtime-dep2': '1.0.0',
+        },
+        devDependencies: {
+          'variant2-dev-dep1': '1.0.0',
+          'variant2-dev-dep2': '1.0.0',
+        },
+        peerDependencies: {
+          'variant2-peer-dep1': '1.0.0',
+          'variant2-peer-dep2': '1.0.0',
+        },
+      },
+      variant3: {
+        dependencies: {
+          'variant3-runtime-dep1': '1.0.0',
+          'variant3-runtime-dep2': '1.0.0',
+        },
+        devDependencies: {
+          'variant3-dev-dep1': '1.0.0',
+          'variant3-dev-dep2': '1.0.0',
+        },
+        peerDependencies: {
+          'variant3-peer-dep1': '1.0.0',
+          'variant3-peer-dep2': '1.0.0',
+        },
+      },
+    };
+    applyUpdates(
+      [
+        {
+          name: 'variant1-runtime-dep1',
+          latestRange: '2.0.0',
+          source: 'variants',
+          variantPattern: 'variant1',
+          targetField: 'dependencies',
+        },
+        {
+          name: 'variant2-dev-dep1',
+          latestRange: '2.0.0',
+          source: 'variants',
+          variantPattern: 'variant2',
+          targetField: 'devDependencies',
+        },
+        {
+          name: 'variant3-peer-dep1',
+          latestRange: '2.0.0',
+          source: 'variants',
+          variantPattern: 'variant3',
+          targetField: 'peerDependencies',
+        },
+      ],
+      {
+        variantPoliciesByPatterns,
+      }
+    );
+    // @ts-ignore
+    expect(variantPoliciesByPatterns.variant1).toStrictEqual({
+      dependencies: {
+        'variant1-runtime-dep1': { version: '2.0.0', resolveFromEnv: true },
+        'variant1-runtime-dep2': '1.0.0',
+      },
+      devDependencies: {
+        'variant1-dev-dep1': '1.0.0',
+        'variant1-dev-dep2': '1.0.0',
+      },
+      peerDependencies: {
+        'variant1-peer-dep1': '1.0.0',
+        'variant1-peer-dep2': '1.0.0',
+      },
+    });
+    // @ts-ignore
+    expect(variantPoliciesByPatterns.variant2).toStrictEqual({
+      dependencies: {
+        'variant2-runtime-dep1': '1.0.0',
+        'variant2-runtime-dep2': '1.0.0',
+      },
+      devDependencies: {
+        'variant2-dev-dep1': '2.0.0',
+        'variant2-dev-dep2': '1.0.0',
+      },
+      peerDependencies: {
+        'variant2-peer-dep1': '1.0.0',
+        'variant2-peer-dep2': '1.0.0',
+      },
+    });
+    // @ts-ignore
+    expect(variantPoliciesByPatterns.variant3).toStrictEqual({
+      dependencies: {
+        'variant3-runtime-dep1': '1.0.0',
+        'variant3-runtime-dep2': '1.0.0',
+      },
+      devDependencies: {
+        'variant3-dev-dep1': '1.0.0',
+        'variant3-dev-dep2': '1.0.0',
+      },
+      peerDependencies: {
+        'variant3-peer-dep1': '2.0.0',
+        'variant3-peer-dep2': '1.0.0',
+      },
+    });
+  });
+  it('should apply updates on component dependencies', () => {
+    const { updatedComponents } = applyUpdates(
+      [
+        {
+          name: 'component1-runtime-dep1',
+          latestRange: '2.0.0',
+          source: 'component',
+          componentId: ComponentID.fromString('scope/component1'),
+          targetField: 'dependencies',
+        },
+        {
+          name: 'component1-dev-dep1',
+          latestRange: '2.0.0',
+          source: 'component',
+          componentId: ComponentID.fromString('scope/component1'),
+          targetField: 'devDependencies',
+        },
+        {
+          name: 'component1-peer-dep1',
+          latestRange: '2.0.0',
+          source: 'component',
+          componentId: ComponentID.fromString('scope/component1'),
+          targetField: 'peerDependencies',
+        },
+      ],
+      {
+        variantPoliciesByPatterns: {},
+      }
+    );
+    // @ts-ignore
+    expect(updatedComponents).toStrictEqual([
+      {
+        componentId: ComponentID.fromString('scope/component1'),
+        config: {
+          policy: {
+            dependencies: {
+              'component1-runtime-dep1': '2.0.0',
+            },
+            devDependencies: {
+              'component1-dev-dep1': '2.0.0',
+            },
+            peerDependencies: {
+              'component1-peer-dep1': '2.0.0',
+            },
+          },
+        },
+      },
+    ]);
+  });
+});

package/apply-updates.ts

@@ -0,0 +1,81 @@
+import { ComponentID } from '@teambit/component';
+import { MergedOutdatedPkg } from './dependency-resolver.main.runtime';
+import { VariantPolicyConfigObject, WorkspacePolicyEntry } from './policy';
+
+export interface UpdatedComponent {
+  componentId: ComponentID;
+  config: Record<string, any>;
+}
+
+/**
+ * Applies updates to policies.
+ */
+export function applyUpdates(
+  outdatedPkgs: Array<Omit<MergedOutdatedPkg, 'currentRange'>>,
+  {
+    variantPoliciesByPatterns,
+  }: {
+    variantPoliciesByPatterns: Record<string, VariantPolicyConfigObject>;
+  }
+): {
+  updatedVariants: string[];
+  updatedComponents: UpdatedComponent[];
+  updatedWorkspacePolicyEntries: WorkspacePolicyEntry[];
+} {
+  const updatedWorkspacePolicyEntries: WorkspacePolicyEntry[] = [];
+  const updatedVariants = new Set<string>();
+  const updatedComponents = new Map<string, UpdatedComponent>();
+
+  for (const outdatedPkg of outdatedPkgs) {
+    if (
+      outdatedPkg.source === 'component' ||
+      (outdatedPkg.source === 'rootPolicy' && outdatedPkg.dependentComponents?.length && !outdatedPkg.isAuto)
+    ) {
+      // eslint-disable-next-line
+      (outdatedPkg.dependentComponents ?? [outdatedPkg.componentId!]).forEach((componentId) => {
+        const id = componentId.toString();
+        if (!updatedComponents.has(id)) {
+          updatedComponents.set(id, { componentId, config: { policy: {} } });
+        }
+        const { config } = updatedComponents.get(id)!; // eslint-disable-line
+        if (!config.policy[outdatedPkg.targetField]) {
+          config.policy[outdatedPkg.targetField] = {};
+        }
+        config.policy[outdatedPkg.targetField][outdatedPkg.name] = outdatedPkg.latestRange;
+      });
+    } else {
+      switch (outdatedPkg.source) {
+        case 'rootPolicy':
+        case 'component-model':
+          updatedWorkspacePolicyEntries.push({
+            dependencyId: outdatedPkg.name,
+            value: {
+              version: outdatedPkg.latestRange,
+            },
+            lifecycleType: outdatedPkg.targetField === 'peerDependencies' ? 'peer' : 'runtime',
+          });
+          break;
+        case 'variants':
+          if (outdatedPkg.variantPattern) {
+            const { variantPattern, targetField, name } = outdatedPkg;
+            updatedVariants.add(outdatedPkg.variantPattern);
+            // eslint-disable-next-line dot-notation, @typescript-eslint/dot-notation
+            if (variantPoliciesByPatterns[variantPattern]?.[targetField]?.[name]?.['version']) {
+              // eslint-disable-line
+              variantPoliciesByPatterns[variantPattern][targetField]![name]['version'] = outdatedPkg.latestRange; // eslint-disable-line
+            } else {
+              variantPoliciesByPatterns[variantPattern][targetField]![name] = outdatedPkg.latestRange; // eslint-disable-line
+            }
+          }
+          break;
+        default:
+          throw new Error(`Unsupported policy source for update: ${outdatedPkg.source}`);
+      }
+    }
+  }
+  return {
+    updatedVariants: Array.from(updatedVariants),
+    updatedComponents: Array.from(updatedComponents.values()),
+    updatedWorkspacePolicyEntries,
+  };
+}

package/dependency-detector.ts

@@ -0,0 +1,5 @@
+export {
+  DetectorHook,
+  DependencyDetector,
+  FileContext,
+} from '@teambit/legacy/dist/consumer/component/dependencies/files-dependency-builder/detector-hook';

package/dependency-env.ts

@@ -0,0 +1,6 @@
+import { EnvHandler } from '@teambit/envs';
+import { DependencyDetector } from './dependency-detector';
+
+export interface DependencyEnv {
+  detectors?(): EnvHandler<DependencyDetector[] | null>;
+}

package/dependency-installer.ts

@@ -0,0 +1,347 @@
+import mapSeries from 'p-map-series';
+import path from 'path';
+import fs from 'fs-extra';
+import { MainAspect, AspectLoaderMain } from '@teambit/aspect-loader';
+import { ComponentMap } from '@teambit/component';
+import { CreateFromComponentsOptions, DependencyResolverMain } from '@teambit/dependency-resolver';
+import { Logger } from '@teambit/logger';
+import { PathAbsolute } from '@teambit/legacy/dist/utils/path';
+import { PeerDependencyRules, ProjectManifest } from '@pnpm/types';
+import { MainAspectNotInstallable, RootDirNotDefined } from './exceptions';
+import { PackageManager, PackageManagerInstallOptions, PackageImportMethod } from './package-manager';
+import { WorkspacePolicy } from './policy';
+
+const DEFAULT_PM_INSTALL_OPTIONS: PackageManagerInstallOptions = {
+  dedupe: true,
+  copyPeerToRuntimeOnRoot: true,
+  copyPeerToRuntimeOnComponents: false,
+  installPeersFromEnvs: false,
+};
+
+const DEFAULT_INSTALL_OPTIONS: InstallOptions = {
+  installTeambitBit: false,
+  excludeExtensionsDependencies: false,
+};
+
+export type DepInstallerContext = {
+  inCapsule?: boolean;
+};
+
+export type InstallArgs = {
+  rootDir: string | undefined;
+  rootPolicy: WorkspacePolicy;
+  componentDirectoryMap: ComponentMap<string>;
+  options: InstallOptions;
+  packageManagerOptions: PackageManagerInstallOptions;
+};
+
+export type InstallOptions = {
+  installTeambitBit: boolean;
+  packageManagerConfigRootDir?: string;
+  resolveVersionsFromDependenciesOnly?: boolean;
+  linkedDependencies?: Record<string, Record<string, string>>;
+  forceTeambitHarmonyLink?: boolean;
+  excludeExtensionsDependencies?: boolean;
+  dedupeInjectedDeps?: boolean;
+};
+
+export type GetComponentManifestsOptions = {
+  componentDirectoryMap: ComponentMap<string>;
+  rootPolicy: WorkspacePolicy;
+  rootDir: string;
+  resolveVersionsFromDependenciesOnly?: boolean;
+  referenceLocalPackages?: boolean;
+  hasRootComponents?: boolean;
+  excludeExtensionsDependencies?: boolean;
+} & Pick<
+  PackageManagerInstallOptions,
+  'dedupe' | 'dependencyFilterFn' | 'copyPeerToRuntimeOnComponents' | 'copyPeerToRuntimeOnRoot' | 'installPeersFromEnvs'
+>;
+
+export type PreInstallSubscriber = (installer: DependencyInstaller, installArgs: InstallArgs) => Promise<void>;
+export type PreInstallSubscriberList = Array<PreInstallSubscriber>;
+
+export type PostInstallSubscriber = (installer: DependencyInstaller, installArgs: InstallArgs) => Promise<void>;
+export type PostInstallSubscriberList = Array<PostInstallSubscriber>;
+
+export class DependencyInstaller {
+  constructor(
+    /**
+     * package manager instance.
+     */
+    private packageManager: PackageManager,
+
+    private aspectLoader: AspectLoaderMain,
+
+    private logger: Logger,
+
+    private dependencyResolver: DependencyResolverMain,
+
+    private rootDir?: string | PathAbsolute,
+
+    private cacheRootDir?: string | PathAbsolute,
+
+    private preInstallSubscriberList?: PreInstallSubscriberList,
+
+    private postInstallSubscriberList?: PostInstallSubscriberList,
+
+    private nodeLinker?: 'hoisted' | 'isolated',
+
+    private packageImportMethod?: PackageImportMethod,
+
+    private sideEffectsCache?: boolean,
+
+    private nodeVersion?: string,
+
+    private engineStrict?: boolean,
+
+    private peerDependencyRules?: PeerDependencyRules,
+
+    private neverBuiltDependencies?: string[],
+
+    private preferOffline?: boolean,
+
+    private installingContext: DepInstallerContext = {}
+  ) {}
+
+  async install(
+    rootDir: string | undefined,
+    rootPolicy: WorkspacePolicy,
+    componentDirectoryMap: ComponentMap<string>,
+    options: InstallOptions = DEFAULT_INSTALL_OPTIONS,
+    packageManagerOptions: PackageManagerInstallOptions = DEFAULT_PM_INSTALL_OPTIONS
+  ) {
+    const finalRootDir = rootDir ?? this.rootDir;
+    if (!finalRootDir) {
+      throw new RootDirNotDefined();
+    }
+    const manifests = await this.getComponentManifests({
+      ...packageManagerOptions,
+      componentDirectoryMap,
+      rootPolicy,
+      rootDir: finalRootDir,
+      resolveVersionsFromDependenciesOnly: options.resolveVersionsFromDependenciesOnly,
+      referenceLocalPackages: packageManagerOptions.rootComponentsForCapsules,
+      excludeExtensionsDependencies: options.excludeExtensionsDependencies,
+    });
+    return this.installComponents(
+      finalRootDir,
+      manifests,
+      rootPolicy,
+      componentDirectoryMap,
+      options,
+      packageManagerOptions
+    );
+  }
+
+  async installComponents(
+    rootDir: string | undefined,
+    manifests: Record<string, ProjectManifest>,
+    rootPolicy: WorkspacePolicy,
+    componentDirectoryMap: ComponentMap<string>,
+    options: InstallOptions = DEFAULT_INSTALL_OPTIONS,
+    packageManagerOptions: PackageManagerInstallOptions = DEFAULT_PM_INSTALL_OPTIONS
+  ): Promise<{ dependenciesChanged: boolean }> {
+    const args = {
+      componentDirectoryMap,
+      options,
+      packageManagerOptions,
+      rootDir,
+      rootPolicy,
+    };
+    await this.runPrePostSubscribers(this.preInstallSubscriberList, 'pre', args);
+    const mainAspect: MainAspect = this.aspectLoader.mainAspect;
+    const finalRootDir = rootDir || this.rootDir;
+    if (!finalRootDir) {
+      throw new RootDirNotDefined();
+    }
+    if (options.linkedDependencies) {
+      manifests = JSON.parse(JSON.stringify(manifests));
+      const linkedDependencies = JSON.parse(
+        JSON.stringify(options.linkedDependencies)
+      ) as typeof options.linkedDependencies;
+      if (linkedDependencies[finalRootDir]) {
+        const directDeps = new Set<string>();
+        Object.values(manifests).forEach((manifest) => {
+          for (const depName of Object.keys({ ...manifest.dependencies, ...manifest.devDependencies })) {
+            directDeps.add(depName);
+          }
+        });
+        for (const manifest of Object.values(manifests)) {
+          if (manifest.name && directDeps.has(manifest.name)) {
+            delete linkedDependencies[finalRootDir][manifest.name];
+          }
+        }
+        if (options.forceTeambitHarmonyLink && manifests[finalRootDir].dependencies?.['@teambit/harmony']) {
+          // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+          delete manifests[finalRootDir].dependencies!['@teambit/harmony'];
+        }
+      }
+      Object.entries(linkedDependencies).forEach(([dir, linkedDeps]) => {
+        if (!manifests[dir]) {
+          manifests[dir] = {};
+        }
+        manifests[dir].dependencies = {
+          ...linkedDeps,
+          ...manifests[dir].dependencies,
+        };
+      });
+    }
+    const hidePackageManagerOutput = !!(this.installingContext.inCapsule && process.env.VERBOSE_PM_OUTPUT !== 'true');
+
+    // Make sure to take other default if passed options with only one option
+    const calculatedPmOpts = {
+      ...DEFAULT_PM_INSTALL_OPTIONS,
+      cacheRootDir: this.cacheRootDir,
+      nodeLinker: this.nodeLinker,
+      packageImportMethod: this.packageImportMethod,
+      sideEffectsCache: this.sideEffectsCache,
+      nodeVersion: this.nodeVersion,
+      engineStrict: this.engineStrict,
+      packageManagerConfigRootDir: options.packageManagerConfigRootDir,
+      peerDependencyRules: this.peerDependencyRules,
+      hidePackageManagerOutput,
+      neverBuiltDependencies: ['core-js', ...(this.neverBuiltDependencies ?? [])],
+      preferOffline: this.preferOffline,
+      dedupeInjectedDeps: options.dedupeInjectedDeps,
+      ...packageManagerOptions,
+    };
+    if (options.installTeambitBit) {
+      if (!mainAspect.version || !mainAspect.packageName) {
+        throw new MainAspectNotInstallable();
+      }
+      const version = mainAspect.version;
+      rootPolicy.add({
+        dependencyId: mainAspect.packageName,
+        lifecycleType: 'runtime',
+        value: {
+          version,
+        },
+      });
+    }
+
+    if (!packageManagerOptions.rootComponents && !packageManagerOptions.keepExistingModulesDir) {
+      // Remove node modules dir for all components dirs, since it might contain left overs from previous install.
+      //
+      // This is not needed when "rootComponents" are used, as in that case the package manager handles the node_modules
+      // and it never leaves node_modules in a broken state.
+      // Removing node_modules in that case would delete useful state information that is used by Yarn or pnpm.
+      await this.cleanCompsNodeModules(componentDirectoryMap);
+    }
+
+    const messagePrefix = 'running package installation';
+    const messageSuffix = `using ${this.packageManager.name}`;
+    const message = this.installingContext?.inCapsule
+      ? `(capsule) ${messagePrefix} in root dir ${this.rootDir} ${messageSuffix}`
+      : `${messagePrefix} ${messageSuffix}`;
+    if (!hidePackageManagerOutput) {
+      this.logger.setStatusLine(message);
+    }
+    const startTime = process.hrtime();
+
+    // TODO: the cache should be probably passed to the package manager constructor not to the install function
+    const installResult = await this.packageManager.install(
+      {
+        rootDir: finalRootDir,
+        manifests,
+        componentDirectoryMap,
+      },
+      calculatedPmOpts
+    );
+    if (!hidePackageManagerOutput) {
+      this.logger.consoleSuccess(`done ${message}`, startTime);
+    }
+    await this.runPrePostSubscribers(this.postInstallSubscriberList, 'post', args);
+    return installResult;
+  }
+
+  public async pruneModules(rootDir: string): Promise<void> {
+    if (!this.packageManager.pruneModules) {
+      return;
+    }
+    await this.packageManager.pruneModules(rootDir);
+  }
+
+  /**
+   * Compute all the component manifests (a.k.a. package.json files) that should be passed to the package manager
+   * in order to install the dependencies.
+   */
+  public async getComponentManifests({
+    componentDirectoryMap,
+    rootPolicy,
+    rootDir,
+    dedupe,
+    dependencyFilterFn,
+    copyPeerToRuntimeOnComponents,
+    copyPeerToRuntimeOnRoot,
+    installPeersFromEnvs,
+    resolveVersionsFromDependenciesOnly,
+    referenceLocalPackages,
+    hasRootComponents,
+    excludeExtensionsDependencies,
+  }: GetComponentManifestsOptions) {
+    const options: CreateFromComponentsOptions = {
+      filterComponentsFromManifests: true,
+      createManifestForComponentsWithoutDependencies: true,
+      dedupe,
+      dependencyFilterFn,
+      resolveVersionsFromDependenciesOnly,
+      referenceLocalPackages,
+      hasRootComponents,
+      excludeExtensionsDependencies,
+    };
+    const workspaceManifest = await this.dependencyResolver.getWorkspaceManifest(
+      undefined,
+      undefined,
+      rootPolicy,
+      rootDir,
+      componentDirectoryMap.components,
+      options,
+      this.installingContext
+    );
+    const manifests: Record<string, ProjectManifest> = componentDirectoryMap
+      .toArray()
+      .reduce((acc, [component, dir]) => {
+        const packageName = this.dependencyResolver.getPackageName(component);
+        const manifest = workspaceManifest.componentsManifestsMap.get(packageName);
+        if (manifest) {
+          acc[dir] = manifest.toJson({ copyPeerToRuntime: copyPeerToRuntimeOnComponents });
+        }
+        return acc;
+      }, {});
+    if (!manifests[rootDir]) {
+      manifests[rootDir] = workspaceManifest.toJson({
+        copyPeerToRuntime: copyPeerToRuntimeOnRoot,
+        installPeersFromEnvs,
+      });
+    }
+    return manifests;
+  }
+
+  private async cleanCompsNodeModules(componentDirectoryMap: ComponentMap<string>) {
+    const promises = componentDirectoryMap.toArray().map(([, dir]) => {
+      const nmDir = path.join(dir, 'node_modules');
+      return fs.remove(nmDir);
+    });
+    return Promise.all(promises);
+  }
+
+  private async runPrePostSubscribers(
+    subscribers: PreInstallSubscriberList | PostInstallSubscriberList = [],
+    type: 'pre' | 'post',
+    args: InstallArgs
+  ): Promise<void> {
+    const message = this.installingContext?.inCapsule
+      ? `(capsule) running ${type} install subscribers in root dir ${this.rootDir}`
+      : `running ${type} install subscribers`;
+    if (!this.installingContext?.inCapsule) {
+      this.logger.setStatusLine(message);
+    }
+    await mapSeries(subscribers, async (subscriber) => {
+      return subscriber(this, args);
+    });
+    if (!this.installingContext?.inCapsule) {
+      this.logger.consoleSuccess(message);
+    }
+  }
+}