@teambit/merging 0.0.336 → 0.0.337

package/dist/merging.main.runtime.d.ts

@@ -8,11 +8,13 @@ import { LaneId } from '@teambit/lane-id';
 import { AutoTagResult } from '@teambit/legacy/dist/scope/component-ops/auto-tag';
 import { Lane, ModelComponent, Version } from '@teambit/legacy/dist/scope/models';
 import { Ref } from '@teambit/legacy/dist/scope/objects';
+import { ConfigMain } from '@teambit/config';
 import { ComponentWriterMain } from '@teambit/component-writer';
 import ConsumerComponent from '@teambit/legacy/dist/consumer/component/consumer-component';
 import { ImporterMain } from '@teambit/importer';
 import { Logger, LoggerMain } from '@teambit/logger';
 import { MergeResultsThreeWay } from '@teambit/legacy/dist/consumer/versions-ops/merge-version/three-way-merge';
+import { WorkspacePolicyConfigKeysNames } from '@teambit/dependency-resolver';
 import { CheckoutMain } from '@teambit/checkout';
 import { SnapsDistance } from '@teambit/legacy/dist/scope/component-ops/snaps-distance';
 import { InstallMain } from '@teambit/install';
@@ -21,6 +23,13 @@ declare type ResolveUnrelatedData = {
     strategy: MergeStrategy;
     head: Ref;
 };
+export declare type WorkspaceDepsUpdates = {
+    [pkgName: string]: [string, string];
+};
+export declare type WorkspaceDepsConflicts = Record<WorkspacePolicyConfigKeysNames, Array<{
+    name: string;
+    version: string;
+}>>;
 export declare type ComponentMergeStatus = {
     currentComponent?: ConsumerComponent | null;
     componentFromModel?: Version;
@@ -63,6 +72,7 @@ export declare type ApplyVersionResults = {
     newFromLaneAdded?: boolean;
     installationError?: Error;
     compilationError?: Error;
+    workspaceDepsUpdates?: WorkspaceDepsUpdates;
 };
 export declare class MergingMain {
     private workspace;
@@ -72,8 +82,9 @@ export declare class MergingMain {
     private logger;
     private componentWriter;
     private importer;
+    private config;
     private consumer;
-    constructor(workspace: Workspace, install: InstallMain, snapping: SnappingMain, checkout: CheckoutMain, logger: Logger, componentWriter: ComponentWriterMain, importer: ImporterMain);
+    constructor(workspace: Workspace, install: InstallMain, snapping: SnappingMain, checkout: CheckoutMain, logger: Logger, componentWriter: ComponentWriterMain, importer: ImporterMain, config: ConfigMain);
     merge(ids: string[], mergeStrategy: MergeStrategy, abort: boolean, resolve: boolean, noSnap: boolean, message: string, build: boolean, skipDependencyInstallation: boolean): Promise<ApplyVersionResults>;
     /**
      * when user is on main, it merges the remote main components into local.
@@ -95,6 +106,7 @@ export declare class MergingMain {
         skipDependencyInstallation?: boolean;
     }): Promise<ApplyVersionResults>;
     private generateConfigMergeConflictFileForAll;
+    private updateWorkspaceJsoncWithDepsIfNeeded;
     /**
      * this function gets called from two different commands:
      * 1. "bit merge <ids...>", when merging a component from a remote to the local.
@@ -121,7 +133,7 @@ export declare class MergingMain {
     static slots: never[];
     static dependencies: import("@teambit/harmony").Aspect[];
     static runtime: import("@teambit/harmony").RuntimeDefinition;
-    static provider([cli, workspace, snapping, checkout, install, loggerMain, compWriter, importer]: [
+    static provider([cli, workspace, snapping, checkout, install, loggerMain, compWriter, importer, config]: [
         CLIMain,
         Workspace,
         SnappingMain,
@@ -129,7 +141,8 @@ export declare class MergingMain {
         InstallMain,
         LoggerMain,
         ComponentWriterMain,
-        ImporterMain
+        ImporterMain,
+        ConfigMain
     ]): Promise<MergingMain>;
 }
 export {};

package/dist/merging.main.runtime.js

@@ -5,6 +5,7 @@ require("core-js/modules/es.array.flat.js");
 require("core-js/modules/es.array.iterator.js");
 require("core-js/modules/es.array.unscopables.flat.js");
 require("core-js/modules/es.promise.js");
+require("core-js/modules/es.regexp.exec.js");
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
@@ -107,6 +108,13 @@ function _chalk() {
   };
   return data;
 }
+function _config() {
+  const data = require("@teambit/config");
+  _config = function () {
+    return data;
+  };
+  return data;
+}
 function _repositories() {
   const data = require("@teambit/legacy/dist/scope/repositories");
   _repositories = function () {
@@ -170,6 +178,13 @@ function _noCommonSnap() {
   };
   return data;
 }
+function _dependencyResolver() {
+  const data = require("@teambit/dependency-resolver");
+  _dependencyResolver = function () {
+    return data;
+  };
+  return data;
+}
 function _checkout() {
   const data = require("@teambit/checkout");
   _checkout = function () {
@@ -184,6 +199,13 @@ function _componentId() {
   };
   return data;
 }
+function _constants() {
+  const data = require("@teambit/legacy/dist/constants");
+  _constants = function () {
+    return data;
+  };
+  return data;
+}
 function _install() {
   const data = require("@teambit/install");
   _install = function () {
@@ -212,12 +234,19 @@ function _configMerger() {
   };
   return data;
 }
+function _configMergeResult() {
+  const data = require("./config-merge-result");
+  _configMergeResult = function () {
+    return data;
+  };
+  return data;
+}
 function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function (nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
 function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
 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 MergingMain {
-  constructor(workspace, install, snapping, checkout, logger, componentWriter, importer) {
+  constructor(workspace, install, snapping, checkout, logger, componentWriter, importer, config) {
     var _this$workspace;
     this.workspace = workspace;
     this.install = install;
@@ -226,6 +255,7 @@ class MergingMain {
     this.logger = logger;
     this.componentWriter = componentWriter;
     this.importer = importer;
+    this.config = config;
     (0, _defineProperty2().default)(this, "consumer", void 0);
     this.consumer = (_this$workspace = this.workspace) === null || _this$workspace === void 0 ? void 0 : _this$workspace.consumer;
   }
@@ -319,8 +349,12 @@ class MergingMain {
         configMergeResult
       });
     });
-    const allConfigMerge = succeededComponents.map(c => c.configMergeResult);
-    await this.generateConfigMergeConflictFileForAll((0, _lodash().compact)(allConfigMerge));
+    const allConfigMerge = (0, _lodash().compact)(succeededComponents.map(c => c.configMergeResult));
+    const {
+      workspaceDepsUpdates,
+      workspaceDepsConflicts
+    } = await this.updateWorkspaceJsoncWithDepsIfNeeded(allConfigMerge);
+    await this.generateConfigMergeConflictFileForAll(allConfigMerge, workspaceDepsConflicts);
     if (localLane) consumer.scope.objects.add(localLane);
     await consumer.scope.objects.persist(); // persist anyway, if localLane is null it should save all main heads
 
@@ -376,11 +410,19 @@ class MergingMain {
       failedComponents,
       mergeSnapResults,
       mergeSnapError,
-      leftUnresolvedConflicts
+      leftUnresolvedConflicts,
+      workspaceDepsUpdates
     };
   }
-  async generateConfigMergeConflictFileForAll(allConfigMerge) {
+  async generateConfigMergeConflictFileForAll(allConfigMerge, workspaceDepsConflicts) {
     const configMergeFile = this.workspace.getConflictMergeFile();
+    if (workspaceDepsConflicts) {
+      const workspaceConflict = new (_configMergeResult().ConfigMergeResult)('WORKSPACE', 'ours', 'theirs', [{
+        id: _dependencyResolver().DependencyResolverAspect.id,
+        conflict: workspaceDepsConflicts
+      }]);
+      allConfigMerge.unshift(workspaceConflict);
+    }
     allConfigMerge.forEach(configMerge => {
       const conflict = configMerge.generateMergeConflictFile();
       if (!conflict) return;
@@ -390,6 +432,129 @@ class MergingMain {
       await configMergeFile.write();
     }
   }
+  async updateWorkspaceJsoncWithDepsIfNeeded(allConfigMerge) {
+    const allResults = allConfigMerge.map(c => c.getDepsResolverResult());
+    const allDeps = {};
+    const allDepsSources = {}; // for logging/debugging purposes
+
+    allConfigMerge.forEach(configMerge => {
+      var _configMerge$getDepsR;
+      const mergedConfig = (_configMerge$getDepsR = configMerge.getDepsResolverResult()) === null || _configMerge$getDepsR === void 0 ? void 0 : _configMerge$getDepsR.mergedConfig;
+      if (!mergedConfig || mergedConfig === '-') return;
+      const policy = mergedConfig.policy || {};
+      _constants().DEPENDENCIES_FIELDS.forEach(depField => {
+        if (!policy[depField]) return;
+        policy[depField].forEach(pkg => {
+          if (pkg.force) return; // we only care about auto-detected dependencies
+          if (allDeps[pkg.name]) {
+            if (!allDeps[pkg.name].includes(pkg.version)) allDeps[pkg.name].push(pkg.version);
+            allDepsSources[pkg.name].push(configMerge.compIdStr);
+            return;
+          }
+          allDeps[pkg.name] = [pkg.version];
+          allDepsSources[pkg.name] = [configMerge.compIdStr];
+        });
+      });
+    });
+    const allConflictDeps = {};
+    const conflictDepsSources = {}; // for logging/debugging purposes
+
+    allConfigMerge.forEach(configMerge => {
+      var _configMerge$getDepsR2;
+      const policy = (_configMerge$getDepsR2 = configMerge.getDepsResolverResult()) === null || _configMerge$getDepsR2 === void 0 ? void 0 : _configMerge$getDepsR2.conflict;
+      if (!policy) return;
+      _constants().DEPENDENCIES_FIELDS.forEach(depField => {
+        if (!policy[depField]) return;
+        policy[depField].forEach(pkg => {
+          if (pkg.force) return; // we only care about auto-detected dependencies
+          if (allConflictDeps[pkg.name]) {
+            if (!allConflictDeps[pkg.name].includes(pkg.version)) allConflictDeps[pkg.name].push(pkg.version);
+            conflictDepsSources[pkg.name].push(configMerge.compIdStr);
+            return;
+          }
+          allConflictDeps[pkg.name] = [pkg.version];
+          conflictDepsSources[pkg.name] = [configMerge.compIdStr];
+        });
+      });
+    });
+    const allPackages = Object.keys(allDeps);
+    const allConflictedPackages = Object.keys(allConflictDeps);
+    if (!allPackages.length && !allConflictedPackages.length) return {};
+    const workspaceConfig = this.config.workspaceConfig;
+    if (!workspaceConfig) throw new Error(`updateWorkspaceJsoncWithDepsIfNeeded unable to get workspace config`);
+    const depResolver = workspaceConfig.extensions.findCoreExtension(_dependencyResolver().DependencyResolverAspect.id);
+    const policy = depResolver === null || depResolver === void 0 ? void 0 : depResolver.config.policy;
+    if (!policy) return {};
+    const workspaceJsonUpdates = {};
+    const WS_DEPS_FIELDS = ['dependencies', 'peerDependencies'];
+    const workspaceJsonConflicts = {
+      dependencies: [],
+      peerDependencies: []
+    };
+    allPackages.forEach(pkgName => {
+      if (allDeps[pkgName].length > 1) {
+        // we only want the deps that the other lane has them in the workspace.json and that all comps use the same dep.
+        return;
+      }
+      _constants().DEPENDENCIES_FIELDS.forEach(depField => {
+        var _policy$depField;
+        if (!((_policy$depField = policy[depField]) !== null && _policy$depField !== void 0 && _policy$depField[pkgName])) return;
+        const currentVer = policy[depField][pkgName];
+        const newVer = allDeps[pkgName][0];
+        if (currentVer === newVer) return;
+        workspaceJsonUpdates[pkgName] = [currentVer, newVer];
+        policy[depField][pkgName] = newVer;
+        this.logger.debug(`update workspace.jsonc: ${pkgName} from ${currentVer} to ${newVer}. Triggered by: ${allDepsSources[pkgName].join(', ')}`);
+      });
+    });
+    allConflictedPackages.forEach(pkgName => {
+      if (allConflictDeps[pkgName].length > 1) {
+        // we only want the deps that the other lane has them in the workspace.json and that all comps use the same dep.
+        return;
+      }
+      const conflict = allConflictDeps[pkgName][0];
+      const [, currentVal, otherVal] = conflict.split('::');
+      WS_DEPS_FIELDS.forEach(depField => {
+        var _policy$depField2;
+        if (!((_policy$depField2 = policy[depField]) !== null && _policy$depField2 !== void 0 && _policy$depField2[pkgName])) return;
+        const currentVer = policy[depField][pkgName];
+        if (currentVer !== currentVal) return;
+        // the version is coming from the workspace.jsonc
+        workspaceJsonConflicts[depField].push({
+          name: pkgName,
+          version: conflict,
+          force: false
+        });
+        this.logger.debug(`conflict workspace.jsonc: ${pkgName} current: ${currentVer}, other: ${otherVal}. Triggered by: ${conflictDepsSources[pkgName].join(', ')}`);
+      });
+    });
+    WS_DEPS_FIELDS.forEach(depField => {
+      if ((0, _lodash().isEmpty)(workspaceJsonConflicts[depField])) delete workspaceJsonConflicts[depField];
+    });
+    if (Object.keys(workspaceJsonConflicts).length) {
+      const conflictedPkgs = Object.keys(workspaceJsonConflicts).map(depField => workspaceJsonConflicts[depField].map(d => d.name)).flat();
+      allResults.forEach(result => {
+        if (result !== null && result !== void 0 && result.conflict) {
+          _constants().DEPENDENCIES_FIELDS.forEach(depField => {
+            var _result$conflict, _result$conflict2;
+            if (!((_result$conflict = result.conflict) !== null && _result$conflict !== void 0 && _result$conflict[depField])) return;
+            result.conflict[depField] = (_result$conflict2 = result.conflict) === null || _result$conflict2 === void 0 ? void 0 : _result$conflict2[depField].filter(dep => !conflictedPkgs.includes(dep.name));
+            if (!result.conflict[depField].length) delete result.conflict[depField];
+          });
+          if ((0, _lodash().isEmpty)(result.conflict)) result.conflict = undefined;
+        }
+      });
+    }
+    if (Object.keys(workspaceJsonUpdates).length) {
+      await workspaceConfig.write();
+    }
+    this.logger.debug('final workspace.jsonc updates', workspaceJsonUpdates);
+    this.logger.debug('final workspace.jsonc conflicts', workspaceJsonConflicts);
+    return {
+      workspaceDepsUpdates: Object.keys(workspaceJsonUpdates).length ? workspaceJsonUpdates : undefined,
+      workspaceDepsConflicts: Object.keys(workspaceJsonConflicts).length ? workspaceJsonConflicts : undefined
+    };
+  }
 
   /**
    * this function gets called from two different commands:
@@ -873,16 +1038,16 @@ other:   ${otherLaneHead.toString()}`);
     }
     return ids.map(id => consumer.getParsedId(id));
   }
-  static async provider([cli, workspace, snapping, checkout, install, loggerMain, compWriter, importer]) {
+  static async provider([cli, workspace, snapping, checkout, install, loggerMain, compWriter, importer, config]) {
     const logger = loggerMain.createLogger(_merging().MergingAspect.id);
-    const merging = new MergingMain(workspace, install, snapping, checkout, logger, compWriter, importer);
+    const merging = new MergingMain(workspace, install, snapping, checkout, logger, compWriter, importer, config);
     cli.register(new (_mergeCmd().MergeCmd)(merging));
     return merging;
   }
 }
 exports.MergingMain = MergingMain;
 (0, _defineProperty2().default)(MergingMain, "slots", []);
-(0, _defineProperty2().default)(MergingMain, "dependencies", [_cli().CLIAspect, _workspace().default, _snapping().default, _checkout().CheckoutAspect, _install().InstallAspect, _logger().LoggerAspect, _componentWriter().ComponentWriterAspect, _importer().default]);
+(0, _defineProperty2().default)(MergingMain, "dependencies", [_cli().CLIAspect, _workspace().default, _snapping().default, _checkout().CheckoutAspect, _install().InstallAspect, _logger().LoggerAspect, _componentWriter().ComponentWriterAspect, _importer().default, _config().ConfigAspect]);
 (0, _defineProperty2().default)(MergingMain, "runtime", _cli().MainRuntime);
 _merging().MergingAspect.addRuntime(MergingMain);