@teambit/dependencies 1.0.1251 → 1.0.1253

package/dependencies-loader/apply-overrides.spec.ts

@@ -1,5 +1,5 @@
 import { expect } from 'chai';
-import { ComponentID } from '@teambit/component-id';
+import { ComponentID, ComponentIdList } from '@teambit/component-id';
 import { Dependency } from '@teambit/legacy.consumer-component';
 import { ComponentOverrides } from '@teambit/legacy.consumer-config';
 import type { DependencyResolverMain } from '@teambit/dependency-resolver';
@@ -42,6 +42,63 @@ describe('ApplyOverrides', () => {
   });
 });
 
+describe('ApplyOverrides outside a workspace, when the dependencies are calculated from a new policy', () => {
+  // e.g. a lane merge from a bare scope. a workspace takes these versions from the policy, .bitmap and node_modules.
+  const buttonId = ComponentID.fromString('my-scope/ui/button@1.0.0');
+  const buttonPkg = '@my-scope/ui.button';
+  function loadForcedDep({ inWorkspace = false, envOwn = false, newPolicy = true } = {}) {
+    const applyOverrides = createApplyOverrides({ dependencies: { [buttonPkg]: '2.0.0' } });
+    const dep = new Dependency(buttonId, [], buttonPkg);
+    applyOverrides.allDependencies = { dependencies: [dep], devDependencies: [], peerDependencies: [] };
+    if (newPolicy) applyOverrides.workspaceComponentIds = ComponentIdList.fromArray(inWorkspace ? [buttonId] : []);
+    if (envOwn) applyOverrides.overridesDependencies.envOwnPkgNames = new Set([buttonPkg]);
+    applyOverrides.getDependenciesToAddManually(undefined, applyOverrides.allDependencies);
+    return { dep, component: (applyOverrides as any).component };
+  }
+  function applyPeerRange(range: string, { inWorkspace = false, version = '1.0.0' } = {}) {
+    const applyOverrides = createApplyOverrides({});
+    const peer = new Dependency(buttonId.changeVersion(version), [], buttonPkg, '1.0.0');
+    applyOverrides.allDependencies = { dependencies: [], devDependencies: [], peerDependencies: [peer] };
+    applyOverrides.workspaceComponentIds = ComponentIdList.fromArray(inWorkspace ? [buttonId] : []);
+    (applyOverrides as any).applyPackageVersion('peerDependencies', buttonPkg, range, undefined, undefined, peer);
+    return peer;
+  }
+  it('should set the version of a forced component dependency and keep it when a new version is snapped along', () => {
+    const { dep, component } = loadForcedDep();
+    expect(dep.id.version).to.equal('2.0.0');
+    expect(component.dependenciesWithVersionFromConfig).to.deep.equal(['my-scope/ui/button']);
+  });
+  it('should set the version of a forced dependency on a workspace component', () => {
+    expect(loadForcedDep({ inWorkspace: true }).dep.id.version).to.equal('2.0.0');
+  });
+  it('should keep the version of an env own dependency on a workspace component, which follows the workspace', () => {
+    const { dep, component } = loadForcedDep({ inWorkspace: true, envOwn: true });
+    expect(dep.id.version).to.equal('1.0.0');
+    expect(component.dependenciesWithVersionFromConfig).to.be.undefined;
+  });
+  it('should keep the version when the policy is not new (e.g. a tag from a scope)', () => {
+    expect(loadForcedDep({ newPolicy: false }).dep.id.version).to.equal('1.0.0');
+  });
+  it('should set the version of a component peer that is out of the range of the policy', () => {
+    const peer = applyPeerRange('2.0.0');
+    expect(peer.id.version).to.equal('2.0.0');
+    expect(peer.versionRange).to.equal('2.0.0');
+  });
+  it('should keep the version of a component peer that is in the range of the policy', () => {
+    expect(applyPeerRange('^1.0.0').id.version).to.equal('1.0.0');
+  });
+  it('should keep the version of a component peer when the range has no minimum version (e.g. an upper bound)', () => {
+    expect(applyPeerRange('<1.0.0').id.version).to.equal('1.0.0');
+  });
+  it('should set the version of a component peer that is a snap, which is out of any semver range', () => {
+    const snap = 'a'.repeat(40);
+    expect(applyPeerRange('^2.0.0', { version: snap }).id.version).to.equal('2.0.0');
+  });
+  it('should keep the version of a component peer that is a workspace component', () => {
+    expect(applyPeerRange('2.0.0', { inWorkspace: true }).id.version).to.equal('1.0.0');
+  });
+});
+
 function createApplyOverridesWithPolicy({
   installed,
   inWorkspacePolicy,

package/dependencies-loader/apply-overrides.ts

@@ -23,6 +23,7 @@ import { ComponentOverrides } from '@teambit/legacy.consumer-config';
 import OverridesDependencies from './overrides-dependencies';
 import { DependenciesData } from './dependencies-data';
 import type { DebugDependencies, FileType } from './auto-detect-deps';
+import { getValidComponentVersion } from './auto-detect-deps';
 
 export type AllDependencies = {
   dependencies: Dependency[];
@@ -62,6 +63,14 @@ export class ApplyOverrides {
    * these overrides are from env/variants/merge-config. not ones with "force: true".
    */
   public autoDetectOverrides: Record<string, any> | undefined;
+  /**
+   * outside a workspace, when the dependencies are calculated from a new policy (e.g. a lane merge from a bare scope):
+   * the components that a workspace would have in its .bitmap, e.g. the components of the lane.
+   * a workspace takes the version of a component dependency from a forced policy, the .bitmap or the installed package
+   * (see updateDependenciesVersions). a scope has no .bitmap and no node_modules, so when this is set, the versions of
+   * the policy are applied here. otherwise, a component dependency keeps its version.
+   */
+  public workspaceComponentIds?: ComponentIdList;
   constructor(
     private component: Component,
     private depsResolver: DependencyResolverMain,
@@ -295,7 +304,7 @@ export class ApplyOverrides {
     dependency: string,
     versionRange: string,
     depField: string
-  ): { componentId?: ComponentID; packageName?: string; versionRange?: string } {
+  ): { componentId?: ComponentID; packageName?: string; versionRange?: string; versionFromConfig?: boolean } {
     if (!this.consumer) {
       // a scope has no node_modules to resolve the package from. if it's a component dependency, use it. otherwise, a
       // forced component dependency (e.g. an env's own peer, which is a runtime dep of the env) is added as a package
@@ -304,13 +313,59 @@ export class ApplyOverrides {
       if (compDep) {
         // same as the workspace (see updateDependenciesVersions), only a peer component dependency keeps its range
         const range = depField === 'peerDependencies' ? versionRange : undefined;
-        return { componentId: compDep.id, packageName: dependency, versionRange: range };
+        const idFromConfig = this.getComponentIdFromForcedVersion(compDep.id, dependency, versionRange);
+        return {
+          componentId: idFromConfig || compDep.id,
+          packageName: dependency,
+          versionRange: range,
+          versionFromConfig: Boolean(idFromConfig),
+        };
       }
     }
     const packageData = this._resolvePackageData(dependency);
     return { componentId: packageData?.componentId, packageName: packageData?.name, versionRange };
   }
 
+  /**
+   * the scope side of resolveFromOverrides() in updateDependenciesVersions(): a forced policy sets the version of a
+   * component dependency. the version of an env's own dependency on a workspace component follows the workspace.
+   */
+  private getComponentIdFromForcedVersion(
+    id: ComponentID,
+    packageName: string,
+    forcedVersion: string
+  ): ComponentID | undefined {
+    if (!this.workspaceComponentIds) return undefined;
+    const isEnvOwn = this.overridesDependencies.envOwnPkgNames.has(packageName);
+    if (isEnvOwn && this.workspaceComponentIds.hasWithoutVersion(id)) return undefined;
+    const { version } = getValidComponentVersion(forcedVersion);
+    return version ? id.changeVersion(version) : undefined;
+  }
+
+  /**
+   * the scope side of the installed version in updateDependenciesVersions(): a workspace installs a component peer in
+   * the range of the policy, and records the installed version. so when the version is out of the range, it's changed
+   * to the version of the range. (when it's in the range, it's kept, as a workspace that has it installed would do)
+   */
+  private setComponentPeerVersionInRange(dependency: Dependency, range: string) {
+    if (!this.workspaceComponentIds || this.workspaceComponentIds.hasWithoutVersion(dependency.id)) return;
+    const version = dependency.id.version;
+    if (!version || !semver.validRange(range)) return;
+    // a snap is not in any semver range, a workspace would install a version of the range instead
+    if (semver.valid(version) && semver.satisfies(version, range)) return;
+    const { version: versionInRange } = getValidComponentVersion(range);
+    // e.g. "<2.0.0" is coerced to "2.0.0", which is out of the range. there's no version to take for such a range.
+    if (versionInRange && semver.satisfies(versionInRange, range)) {
+      dependency.id = dependency.id.changeVersion(versionInRange);
+    }
+  }
+
+  private setVersionFromConfig(id: ComponentID) {
+    const idStr = id.toStringWithoutVersion();
+    const dependenciesWithVersionFromConfig = (this.component.dependenciesWithVersionFromConfig ||= []);
+    if (!dependenciesWithVersionFromConfig.includes(idStr)) dependenciesWithVersionFromConfig.push(idStr);
+  }
+
   private findComponentDepByPackageName(packageName: string): Dependency | undefined {
     const { dependencies, devDependencies, peerDependencies } = this.allDependencies;
     const isMatch = (dep: Dependency) => dep.packageName === packageName;
@@ -341,6 +396,9 @@ export class ApplyOverrides {
           const dependencyExist = existingDependencies[depField].find((d) =>
             d.id.isEqualWithoutVersion(componentData.componentId)
           );
+          // the version-maker keeps it, rather than changing it to a version snapped along (see updateDependenciesVersions)
+          if (componentData.versionFromConfig) this.setVersionFromConfig(componentData.componentId);
+          if (dependencyExist && componentData.versionFromConfig) dependencyExist.id = componentData.componentId;
           if (!dependencyExist) {
             this.overridesDependencies._addManuallyAddedDep(depField, componentData.componentId.toString());
             components[depField] ? components[depField].push(componentData) : (components[depField] = [componentData]);
@@ -732,6 +790,7 @@ export class ApplyOverrides {
     if ((existsInCompsDeps || existsInCompsDevDeps) && field === 'peerDependencies') {
       const comp = (existsInCompsDeps ?? existsInCompsDevDeps) as Dependency;
       comp.versionRange = pkgVal;
+      this.setComponentPeerVersionInRange(comp, pkgVal);
       this.allDependencies.peerDependencies.push(comp);
     } else {
       // a package has no separate version and range, so a "+" placeholder is resolved here.
@@ -743,6 +802,7 @@ export class ApplyOverrides {
 
     if (existsInCompsPeerDeps) {
       existsInCompsPeerDeps.versionRange = pkgVal;
+      this.setComponentPeerVersionInRange(existsInCompsPeerDeps, pkgVal);
     }
   }
 

package/dependencies-loader/dependencies-loader.ts

@@ -16,6 +16,7 @@ import type { DevFilesMain } from '@teambit/dev-files';
 import type { Logger } from '@teambit/logger';
 import type { AspectLoaderMain } from '@teambit/aspect-loader';
 import type { DependenciesOverridesData } from '@teambit/legacy.consumer-config';
+import type { ComponentIdList } from '@teambit/component-id';
 import { DependenciesData } from './dependencies-data';
 import { updateDependenciesVersions } from './dependencies-versions-resolver';
 import type { DebugDependencies } from './auto-detect-deps';
@@ -67,8 +68,13 @@ export class DependenciesLoader {
    * `autoDetectOverrides` are the non-force policy entries (versions for dependencies that were detected). a workspace
    * calculates them on its own, a scope gets them from the caller.
    */
-  async loadFromScope(dependenciesData: Partial<DependenciesData>, autoDetectOverrides?: DependenciesOverridesData) {
+  async loadFromScope(
+    dependenciesData: Partial<DependenciesData>,
+    autoDetectOverrides?: DependenciesOverridesData,
+    workspaceComponentIds?: ComponentIdList
+  ) {
     const applyOverrides = new ApplyOverrides(this.component, this.depsResolver, this.logger);
+    applyOverrides.workspaceComponentIds = workspaceComponentIds;
     const { allDependencies, allPackagesDependencies, issues } = dependenciesData;
     if (allDependencies) applyOverrides.allDependencies = allDependencies;
     if (allPackagesDependencies) applyOverrides.allPackagesDependencies = allPackagesDependencies;

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

@@ -1,4 +1,5 @@
 import type { ComponentID } from '@teambit/component-id';
+import { ComponentIdList } from '@teambit/component-id';
 import type { IssuesList } from '@teambit/component-issues';
 import type { ConsumerComponent as Component } from '@teambit/legacy.consumer-component';
 import { Dependency } from '@teambit/legacy.consumer-component';
@@ -43,6 +44,14 @@ export declare class ApplyOverrides {
      * these overrides are from env/variants/merge-config. not ones with "force: true".
      */
     autoDetectOverrides: Record<string, any> | undefined;
+    /**
+     * outside a workspace, when the dependencies are calculated from a new policy (e.g. a lane merge from a bare scope):
+     * the components that a workspace would have in its .bitmap, e.g. the components of the lane.
+     * a workspace takes the version of a component dependency from a forced policy, the .bitmap or the installed package
+     * (see updateDependenciesVersions). a scope has no .bitmap and no node_modules, so when this is set, the versions of
+     * the policy are applied here. otherwise, a component dependency keeps its version.
+     */
+    workspaceComponentIds?: ComponentIdList;
     constructor(component: Component, depsResolver: DependencyResolverMain, logger: Logger, workspace?: Workspace | undefined);
     private setOverridesDependencies;
     private getEnvExtendsDeps;
@@ -93,6 +102,18 @@ export declare class ApplyOverrides {
     private removeIgnoredPackagesByOverrides;
     private _resolvePackageData;
     private _getComponentIdToAdd;
+    /**
+     * the scope side of resolveFromOverrides() in updateDependenciesVersions(): a forced policy sets the version of a
+     * component dependency. the version of an env's own dependency on a workspace component follows the workspace.
+     */
+    private getComponentIdFromForcedVersion;
+    /**
+     * the scope side of the installed version in updateDependenciesVersions(): a workspace installs a component peer in
+     * the range of the policy, and records the installed version. so when the version is out of the range, it's changed
+     * to the version of the range. (when it's in the range, it's kept, as a workspace that has it installed would do)
+     */
+    private setComponentPeerVersionInRange;
+    private setVersionFromConfig;
     private findComponentDepByPackageName;
     getDependenciesToAddManually(packageJson: Record<string, any> | null | undefined, existingDependencies: AllDependencies): {
         components: Record<string, any>;

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

@@ -102,6 +102,13 @@ function _dependenciesData() {
   };
   return data;
 }
+function _autoDetectDeps() {
+  const data = require("./auto-detect-deps");
+  _autoDetectDeps = function () {
+    return data;
+  };
+  return data;
+}
 function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
 function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
 function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
@@ -138,6 +145,14 @@ class ApplyOverrides {
      * these overrides are from env/variants/merge-config. not ones with "force: true".
      */
     _defineProperty(this, "autoDetectOverrides", void 0);
+    /**
+     * outside a workspace, when the dependencies are calculated from a new policy (e.g. a lane merge from a bare scope):
+     * the components that a workspace would have in its .bitmap, e.g. the components of the lane.
+     * a workspace takes the version of a component dependency from a forced policy, the .bitmap or the installed package
+     * (see updateDependenciesVersions). a scope has no .bitmap and no node_modules, so when this is set, the versions of
+     * the policy are applied here. otherwise, a component dependency keeps its version.
+     */
+    _defineProperty(this, "workspaceComponentIds", void 0);
     this.componentId = component.componentId;
     this.componentFromModel = this.component.componentFromModel;
     this.allDependencies = {
@@ -335,10 +350,12 @@ class ApplyOverrides {
       if (compDep) {
         // same as the workspace (see updateDependenciesVersions), only a peer component dependency keeps its range
         const range = depField === 'peerDependencies' ? versionRange : undefined;
+        const idFromConfig = this.getComponentIdFromForcedVersion(compDep.id, dependency, versionRange);
         return {
-          componentId: compDep.id,
+          componentId: idFromConfig || compDep.id,
           packageName: dependency,
-          versionRange: range
+          versionRange: range,
+          versionFromConfig: Boolean(idFromConfig)
         };
       }
     }
@@ -349,6 +366,45 @@ class ApplyOverrides {
       versionRange
     };
   }
+
+  /**
+   * the scope side of resolveFromOverrides() in updateDependenciesVersions(): a forced policy sets the version of a
+   * component dependency. the version of an env's own dependency on a workspace component follows the workspace.
+   */
+  getComponentIdFromForcedVersion(id, packageName, forcedVersion) {
+    if (!this.workspaceComponentIds) return undefined;
+    const isEnvOwn = this.overridesDependencies.envOwnPkgNames.has(packageName);
+    if (isEnvOwn && this.workspaceComponentIds.hasWithoutVersion(id)) return undefined;
+    const {
+      version
+    } = (0, _autoDetectDeps().getValidComponentVersion)(forcedVersion);
+    return version ? id.changeVersion(version) : undefined;
+  }
+
+  /**
+   * the scope side of the installed version in updateDependenciesVersions(): a workspace installs a component peer in
+   * the range of the policy, and records the installed version. so when the version is out of the range, it's changed
+   * to the version of the range. (when it's in the range, it's kept, as a workspace that has it installed would do)
+   */
+  setComponentPeerVersionInRange(dependency, range) {
+    if (!this.workspaceComponentIds || this.workspaceComponentIds.hasWithoutVersion(dependency.id)) return;
+    const version = dependency.id.version;
+    if (!version || !_semver().default.validRange(range)) return;
+    // a snap is not in any semver range, a workspace would install a version of the range instead
+    if (_semver().default.valid(version) && _semver().default.satisfies(version, range)) return;
+    const {
+      version: versionInRange
+    } = (0, _autoDetectDeps().getValidComponentVersion)(range);
+    // e.g. "<2.0.0" is coerced to "2.0.0", which is out of the range. there's no version to take for such a range.
+    if (versionInRange && _semver().default.satisfies(versionInRange, range)) {
+      dependency.id = dependency.id.changeVersion(versionInRange);
+    }
+  }
+  setVersionFromConfig(id) {
+    const idStr = id.toStringWithoutVersion();
+    const dependenciesWithVersionFromConfig = this.component.dependenciesWithVersionFromConfig ||= [];
+    if (!dependenciesWithVersionFromConfig.includes(idStr)) dependenciesWithVersionFromConfig.push(idStr);
+  }
   findComponentDepByPackageName(packageName) {
     const {
       dependencies,
@@ -375,6 +431,9 @@ class ApplyOverrides {
             return;
           }
           const dependencyExist = existingDependencies[depField].find(d => d.id.isEqualWithoutVersion(componentData.componentId));
+          // the version-maker keeps it, rather than changing it to a version snapped along (see updateDependenciesVersions)
+          if (componentData.versionFromConfig) this.setVersionFromConfig(componentData.componentId);
+          if (dependencyExist && componentData.versionFromConfig) dependencyExist.id = componentData.componentId;
           if (!dependencyExist) {
             this.overridesDependencies._addManuallyAddedDep(depField, componentData.componentId.toString());
             components[depField] ? components[depField].push(componentData) : components[depField] = [componentData];
@@ -695,6 +754,7 @@ class ApplyOverrides {
     if ((existsInCompsDeps || existsInCompsDevDeps) && field === 'peerDependencies') {
       const comp = existsInCompsDeps ?? existsInCompsDevDeps;
       comp.versionRange = pkgVal;
+      this.setComponentPeerVersionInRange(comp, pkgVal);
       this.allDependencies.peerDependencies.push(comp);
     } else {
       // a package has no separate version and range, so a "+" placeholder is resolved here.
@@ -703,6 +763,7 @@ class ApplyOverrides {
     }
     if (existsInCompsPeerDeps) {
       existsInCompsPeerDeps.versionRange = pkgVal;
+      this.setComponentPeerVersionInRange(existsInCompsPeerDeps, pkgVal);
     }
   }
   async applyAutoDetectedPeersFromEnvOnEnvItSelf() {