@teambit/merge-lanes 1.0.161 → 1.0.163

package/dist/merge-lanes.main.runtime.js

@@ -40,7 +40,7 @@ function _lanes() {
   return data;
 }
 function _merging() {
-  const data = _interopRequireDefault(require("@teambit/merging"));
+  const data = _interopRequireWildcard(require("@teambit/merging"));
   _merging = function () {
     return data;
   };
@@ -74,16 +74,16 @@ function _pMapSeries() {
   };
   return data;
 }
-function _scope() {
-  const data = require("@teambit/scope");
-  _scope = function () {
+function _mergeVersion() {
+  const data = require("@teambit/legacy/dist/consumer/versions-ops/merge-version");
+  _mergeVersion = function () {
     return data;
   };
   return data;
 }
-function _scopeComponentsImporter() {
-  const data = _interopRequireDefault(require("@teambit/legacy/dist/scope/component-ops/scope-components-importer"));
-  _scopeComponentsImporter = function () {
+function _scope() {
+  const data = require("@teambit/scope");
+  _scope = function () {
     return data;
   };
   return data;
@@ -206,13 +206,18 @@ class MergeLanesMain {
     this.importer = importer;
     this.checkout = checkout;
   }
-
-  // eslint-disable-next-line complexity
-  async mergeLane(laneName, options) {
+  async mergeLaneByCLI(laneName, options) {
     if (!this.workspace) {
       throw new (_bitError().BitError)(`unable to merge a lane outside of Bit workspace`);
     }
-    const consumer = this.workspace.consumer;
+    const currentLaneId = this.workspace.consumer.getCurrentLaneId();
+    const otherLaneId = await this.workspace.consumer.getParsedLaneId(laneName);
+    return this.mergeLane(otherLaneId, currentLaneId, options);
+  }
+
+  // eslint-disable-next-line complexity
+  async mergeLane(otherLaneId, currentLaneId, options) {
+    const consumer = this.workspace?.consumer;
     const {
       mergeStrategy,
       noSnap,
@@ -231,18 +236,17 @@ class MergeLanesMain {
       skipFetch,
       excludeNonLaneComps
     } = options;
-    const currentLaneId = consumer.getCurrentLaneId();
+    const legacyScope = this.scope.legacyScope;
     if (tag && !currentLaneId.isDefault()) {
       throw new (_bitError().BitError)(`--tag only possible when on main. currently checked out to ${currentLaneId.toString()}`);
     }
-    const otherLaneId = await consumer.getParsedLaneId(laneName);
     if (otherLaneId.isEqual(currentLaneId)) {
       throw new (_bitError().BitError)(`unable to merge lane "${otherLaneId.toString()}", you're already at this lane. to get updates, simply run "bit checkout head"`);
     }
     if (resolveUnrelated && currentLaneId.isDefault()) {
       throw new (_bitError().BitError)(`unable to resolve unrelated when on main. switch to ${otherLaneId.toString()} and run "bit lane merge main --resolve-unrelated"`);
     }
-    const currentLane = currentLaneId.isDefault() ? null : await consumer.scope.loadLane(currentLaneId);
+    const currentLane = currentLaneId.isDefault() ? null : await legacyScope.loadLane(currentLaneId);
     const isDefaultLane = otherLaneId.isDefault();
     if (isDefaultLane) {
       if (!skipFetch) {
@@ -253,13 +257,13 @@ class MergeLanesMain {
     }
     let laneToFetchArtifactsFrom;
     const getOtherLane = async () => {
-      let lane = await consumer.scope.loadLane(otherLaneId);
+      let lane = await legacyScope.loadLane(otherLaneId);
       const shouldFetch = !lane || !skipFetch && !lane.isNew;
       if (shouldFetch) {
         // don't assign `lane` to the result of this command. otherwise, if you have local snaps, it'll ignore them and use the remote-lane.
         const otherLane = await this.lanes.fetchLaneWithItsComponents(otherLaneId);
         laneToFetchArtifactsFrom = otherLane;
-        lane = await consumer.scope.loadLane(otherLaneId);
+        lane = await legacyScope.loadLane(otherLaneId);
       }
       return lane;
     };
@@ -286,9 +290,9 @@ class MergeLanesMain {
       mergeStrategy
     }, currentLane, otherLane);
     if (pattern) {
-      const componentIds = await this.workspace.resolveMultipleComponentIds(idsToMerge);
-      const compIdsFromPattern = await this.workspace.filterIdsFromPoolIdsByPattern(pattern, componentIds);
-      allComponentsStatus = await filterComponentsStatus(allComponentsStatus, compIdsFromPattern, idsToMerge, this.workspace, includeDeps, otherLane || undefined, shouldSquash);
+      const componentIds = idsToMerge;
+      const compIdsFromPattern = await (this.workspace || this.scope).filterIdsFromPoolIdsByPattern(pattern, componentIds);
+      allComponentsStatus = await filterComponentsStatus(allComponentsStatus, compIdsFromPattern, idsToMerge, legacyScope, includeDeps, otherLane || undefined, shouldSquash);
       idsToMerge.forEach(bitId => {
         if (!allComponentsStatus.find(c => c.id.isEqualWithoutVersion(bitId))) {
           allComponentsStatus.push({
@@ -299,10 +303,10 @@ class MergeLanesMain {
         }
       });
     }
-    if (existingOnWorkspaceOnly) {
+    if (existingOnWorkspaceOnly && this.workspace) {
       const workspaceIds = await this.workspace.listIds();
       const compIdsFromPattern = workspaceIds.filter(id => allComponentsStatus.find(c => c.id.isEqualWithoutVersion(id)));
-      allComponentsStatus = await filterComponentsStatus(allComponentsStatus, compIdsFromPattern, idsToMerge, this.workspace, includeDeps, otherLane || undefined, shouldSquash);
+      allComponentsStatus = await filterComponentsStatus(allComponentsStatus, compIdsFromPattern, idsToMerge, legacyScope, includeDeps, otherLane || undefined, shouldSquash);
       idsToMerge.forEach(bitId => {
         if (!allComponentsStatus.find(c => c.id.isEqualWithoutVersion(bitId))) {
           allComponentsStatus.push({
@@ -315,14 +319,14 @@ class MergeLanesMain {
     }
     (0, _checkout().throwForFailures)(allComponentsStatus);
     if (shouldSquash) {
-      await squashSnaps(allComponentsStatus, otherLaneId, consumer);
+      await squashSnaps(allComponentsStatus, currentLaneId, otherLaneId, legacyScope);
     }
     if (laneToFetchArtifactsFrom) {
       const ids = allComponentsStatus.map(c => c.id);
       await this.importer.importHeadArtifactsFromLane(laneToFetchArtifactsFrom, ids, true);
     }
-    const lastMerged = new (_lastMerged().LastMerged)(this.scope, consumer, this.logger);
-    const snapshot = await lastMerged.takeSnapshot(currentLane);
+    const lastMerged = consumer ? new (_lastMerged().LastMerged)(this.scope, consumer, this.logger) : undefined;
+    const snapshot = await lastMerged?.takeSnapshot(currentLane);
     const mergeResults = await this.merging.mergeSnaps({
       mergeStrategy,
       allComponentsStatus,
@@ -334,7 +338,7 @@ class MergeLanesMain {
       build,
       skipDependencyInstallation
     });
-    await lastMerged.persistSnapshot(snapshot);
+    if (snapshot) await lastMerged?.persistSnapshot(snapshot);
     const mergedSuccessfully = !mergeResults.failedComponents || mergeResults.failedComponents.length === 0 || mergeResults.failedComponents.every(failedComponent => failedComponent.unchangedLegitimately);
     let deleteResults = {};
     if (!keepReadme && otherLane && otherLane.readmeComponent && mergedSuccessfully) {
@@ -348,7 +352,7 @@ class MergeLanesMain {
       };
     }
     const configMergeResults = allComponentsStatus.map(c => c.configMergeResult);
-    await this.workspace.consumer.onDestroy(`lane-merge (${otherLaneId.name})`);
+    await this.workspace?.consumer.onDestroy(`lane-merge (${otherLaneId.name})`);
     return {
       mergeResults,
       deleteResults,
@@ -408,19 +412,20 @@ class MergeLanesMain {
     if (this.workspace) {
       throw new (_bitError().BitError)(`unable to run this command from a workspace, please create a new bare-scope and run it from there`);
     }
-    const fromLaneId = _laneId().LaneId.parse(fromLane);
-    const fromLaneObj = await this.lanes.importLaneObject(fromLaneId);
+    const fromLaneId = await this.lanes.parseLaneId(fromLane);
+    const fromLaneObj = fromLaneId.isDefault() ? undefined : await this.lanes.importLaneObject(fromLaneId);
     const toLaneId = toLane === _laneId().DEFAULT_LANE ? this.lanes.getDefaultLaneId() : _laneId().LaneId.parse(toLane);
     const toLaneObj = toLaneId.isDefault() ? undefined : await this.lanes.importLaneObject(toLaneId);
-    const fromLaneBitIds = fromLaneObj.toBitIds();
+    const fromLaneBitIds = fromLaneObj?.toComponentIds();
+    const toLaneCompIds = toLaneObj?.toComponentIds();
+    const laneIds = fromLaneBitIds || toLaneCompIds; // one of them must be defined.
     const getIdsToMerge = async () => {
-      if (!options.pattern) return fromLaneBitIds;
-      const laneCompIds = await this.scope.resolveMultipleComponentIds(fromLaneBitIds);
-      const ids = await this.scope.filterIdsFromPoolIdsByPattern(options.pattern, laneCompIds);
+      if (!options.pattern) return laneIds;
+      const ids = await this.scope.filterIdsFromPoolIdsByPattern(options.pattern, laneIds);
       return _componentId().ComponentIdList.fromArray(ids.map(id => id));
     };
     const idsToMerge = await getIdsToMerge();
-    const scopeComponentsImporter = _scopeComponentsImporter().default.getInstance(this.scope.legacyScope);
+    const scopeComponentsImporter = this.scope.legacyScope.scopeImporter;
     await scopeComponentsImporter.importWithoutDeps(idsToMerge.toVersionLatest(), {
       cache: false,
       lane: fromLaneObj,
@@ -437,7 +442,77 @@ class MergeLanesMain {
       includeVersionHistory: true,
       reason: `of "to" lane (${toLaneId.name}) for lane-merge to get all version-history`
     });
-    await this.importer.importHeadArtifactsFromLane(fromLaneObj, undefined, true);
+    await this.importer.importHeadArtifactsFromLane(fromLaneObj || toLaneObj, undefined, true);
+    const shouldSquash = !toLaneObj && !options.noSquash; // only when merging to main we squash.
+
+    const exportIfNeeded = async (idsToExport, laneToExport) => {
+      if (!options.push) return [];
+      const compIdsList = _componentId().ComponentIdList.fromArray(idsToExport);
+      const {
+        exported
+      } = await this.exporter.exportMany({
+        scope: this.scope.legacyScope,
+        ids: compIdsList,
+        idsWithFutureScope: compIdsList,
+        laneObject: laneToExport,
+        allVersions: false,
+        // no need to export anything else other than the head. the normal calculation of what to export won't apply here
+        // as it is done from the scope.
+        exportHeadsOnly: shouldSquash,
+        // all artifacts must be pushed. they're all considered "external" in this case, because it's running from a
+        // bare-scope, but we don't want to ignore them, otherwise, they'll be missing from the component-scopes.
+        ignoreMissingExternalArtifacts: false,
+        exportOrigin: 'lane-merge'
+      });
+      return exported;
+    };
+    if (fromLaneId.isDefault()) {
+      // current -> target (to)
+      // other -> source (from)
+      options.mergeStrategy = 'manual';
+      options.excludeNonLaneComps = true;
+      options.skipDependencyInstallation = true;
+      this.scope.legacyScope.setCurrentLaneId(toLaneId);
+      this.scope.legacyScope.scopeImporter.shouldOnlyFetchFromCurrentLane = true;
+      const result = await this.mergeLane(fromLaneId, toLaneId, options);
+      const {
+        mergeSnapResults,
+        leftUnresolvedConflicts,
+        failedComponents,
+        components
+      } = result.mergeResults;
+      this.logger.debug(`found the following config conflicts: ${result.configMergeResults.map(c => `\n${c.compIdStr}\n${c.generateMergeConflictFile()}`).join('\n')}`);
+      const componentsWithConfigConflicts = result.configMergeResults.filter(c => c.hasConflicts()).map(c => c.compIdStr);
+      const conflicts = [];
+      const merged = [];
+      components?.forEach(c => {
+        const files = Object.keys(c.filesStatus).filter(f => c.filesStatus[f] === _mergeVersion().FileStatus.manual || c.filesStatus[f] === _mergeVersion().FileStatus.binaryConflict);
+        const config = componentsWithConfigConflicts.includes(c.id.toStringWithoutVersion());
+        if (files.length || config) {
+          conflicts.push({
+            id: c.id,
+            files,
+            config
+          });
+        } else merged.push(c.id);
+      });
+      const snappedIds = mergeSnapResults?.snappedComponents.map(c => c.id) || [];
+      const laneToExport = await this.lanes.loadLane(toLaneId); // needs to be loaded again after the merge as it changed
+      const exportedIds = leftUnresolvedConflicts ? [] : await exportIfNeeded(idsToMerge.map(id => id.changeVersion(undefined)), laneToExport);
+      return {
+        mergedNow: merged,
+        mergedPreviously: failedComponents?.filter(({
+          unchangedMessage
+        }) => unchangedMessage === _merging().compIsAlreadyMergedMsg).map(c => c.id) || [],
+        exportedIds,
+        unmerged: failedComponents?.map(c => ({
+          id: c.id,
+          reason: c.unchangedMessage
+        })) || [],
+        conflicts,
+        snappedIds
+      };
+    }
     await this.throwIfNotUpToDate(fromLaneId, toLaneId);
     const repo = this.scope.legacyScope.objects;
     // loop through all components, make sure they're all ahead of main (it might not be on main yet).
@@ -445,7 +520,6 @@ class MergeLanesMain {
     // then, change the component object head to point to this changed version
     const mergedPreviously = [];
     const mergedNow = [];
-    const shouldSquash = !toLaneObj && !options.noSquash; // only when merging to main we squash.
     const log = await getLogForSquash(fromLaneId);
     const bitObjectsPerComp = await (0, _pMapSeries().default)(idsToMerge, async id => {
       const modelComponent = await this.scope.legacyScope.getModelComponent(id);
@@ -487,32 +561,16 @@ class MergeLanesMain {
     const bitObjectsFlat = bitObjects.flat();
     if (toLaneObj) bitObjectsFlat.push(toLaneObj);
     await repo.writeObjectsToTheFS(bitObjectsFlat);
-    let exportedIds = [];
-    if (options.push) {
-      const ids = (0, _lodash().compact)(bitObjectsPerComp).map(b => b.id);
-      const bitIds = _componentId().ComponentIdList.fromArray(ids);
-      const {
-        exported
-      } = await this.exporter.exportMany({
-        scope: this.scope.legacyScope,
-        ids: shouldSquash ? bitIds : new (_componentId().ComponentIdList)(),
-        idsWithFutureScope: shouldSquash ? bitIds : new (_componentId().ComponentIdList)(),
-        laneObject: toLaneObj,
-        allVersions: false,
-        // no need to export anything else other than the head. the normal calculation of what to export won't apply here
-        // as it is done from the scope.
-        exportHeadsOnly: shouldSquash,
-        // all artifacts must be pushed. they're all considered "external" in this case, because it's running from a
-        // bare-scope, but we don't want to ignore them, otherwise, they'll be missing from the component-scopes.
-        ignoreMissingExternalArtifacts: false,
-        exportOrigin: 'lane-merge'
-      });
-      exportedIds = exported.map(id => id.toString());
-    }
+    const ids = (0, _lodash().compact)(bitObjectsPerComp).map(b => b.id);
+    const exportedIds = await exportIfNeeded(ids, toLaneObj);
     return {
-      mergedPreviously: mergedPreviously.map(id => id.toString()),
-      mergedNow: mergedNow.map(id => id.toString()),
-      exportedIds
+      mergedPreviously,
+      mergedNow,
+      exportedIds,
+      unmerged: mergedPreviously.map(id => ({
+        id,
+        reason: 'already merged'
+      }))
     };
   }
   async throwIfNotUpToDate(fromLaneId, toLaneId) {
@@ -539,7 +597,7 @@ exports.MergeLanesMain = MergeLanesMain;
 _defineProperty(MergeLanesMain, "slots", []);
 _defineProperty(MergeLanesMain, "dependencies", [_lanes().LanesAspect, _cli().CLIAspect, _workspace().default, _merging().default, _logger().LoggerAspect, _remove().RemoveAspect, _scope().ScopeAspect, _export().ExportAspect, _importer().default, _checkout().default, _globalConfig().default]);
 _defineProperty(MergeLanesMain, "runtime", _cli().MainRuntime);
-async function filterComponentsStatus(allComponentsStatus, compIdsToKeep, allBitIds, workspace, includeDeps = false, otherLane,
+async function filterComponentsStatus(allComponentsStatus, compIdsToKeep, allBitIds, legacyScope, includeDeps = false, otherLane,
 // lane that gets merged into the current lane. if not provided, it's main that gets merged into the current lane
 shouldSquash) {
   const bitIdsFromPattern = _componentId().ComponentIdList.fromArray(compIdsToKeep);
@@ -571,7 +629,7 @@ shouldSquash) {
     if (!targetVersions.length) {
       return undefined;
     }
-    const modelComponent = await workspace.consumer.scope.getModelComponent(compId);
+    const modelComponent = await legacyScope.getModelComponent(compId);
     if (shouldSquash) {
       // no need to check all versions, we merge only the head
       const headOnTarget = otherLane ? otherLane.getComponent(compId)?.head : modelComponent.head;
@@ -589,7 +647,7 @@ shouldSquash) {
 
   // all these versions needs to be imported to load them later and check whether they have dependencies on the target lane
   const toImport = (0, _lodash().compact)(versionsToCheckPerId).map(c => c.targetVersions.map(v => c.compId.changeVersion(v.toString()))).flat();
-  await workspace.consumer.scope.scopeImporter.importWithoutDeps(_componentId().ComponentIdList.fromArray(toImport), {
+  await legacyScope.scopeImporter.importWithoutDeps(_componentId().ComponentIdList.fromArray(toImport), {
     lane: otherLane,
     cache: true,
     includeVersionHistory: false,
@@ -601,7 +659,7 @@ shouldSquash) {
     modelComponent
   }) => {
     await (0, _pMapSeries().default)(targetVersions, async remoteVersion => {
-      const versionObj = await modelComponent.loadVersion(remoteVersion.toString(), workspace.consumer.scope.objects);
+      const versionObj = await modelComponent.loadVersion(remoteVersion.toString(), legacyScope.objects);
       const flattenedDeps = versionObj.getAllFlattenedDependencies();
       const depsNotIncludeInPattern = flattenedDeps.filter(id => bitIdsNotFromPattern.find(bitId => bitId.isEqualWithoutVersion(id)));
       if (!depsNotIncludeInPattern.length) {
@@ -609,7 +667,7 @@ shouldSquash) {
       }
       const depsOnLane = [];
       await Promise.all(depsNotIncludeInPattern.map(async dep => {
-        const isOnLane = await workspace.consumer.scope.isIdOnLane(dep, otherLane);
+        const isOnLane = await legacyScope.isIdOnLane(dep, otherLane);
         if (isOnLane) {
           depsOnLane.push(dep);
         }
@@ -656,8 +714,8 @@ async function getLogForSquash(otherLaneId) {
   });
   return log;
 }
-async function squashSnaps(allComponentsStatus, otherLaneId, consumer) {
-  const currentLaneName = consumer.getCurrentLaneId().name;
+async function squashSnaps(allComponentsStatus, currentLaneId, otherLaneId, scope) {
+  const currentLaneName = currentLaneId.name;
   const succeededComponents = allComponentsStatus.filter(c => !c.unchangedMessage);
   const log = await getLogForSquash(otherLaneId);
   await Promise.all(succeededComponents.map(async ({
@@ -668,12 +726,12 @@ async function squashSnaps(allComponentsStatus, otherLaneId, consumer) {
     if (!divergeData) {
       throw new Error(`unable to squash. divergeData is missing from ${id.toString()}`);
     }
-    const modifiedComp = await squashOneComp(currentLaneName, otherLaneId, id, divergeData, log, consumer.scope, componentFromModel);
+    const modifiedComp = await squashOneComp(currentLaneName, otherLaneId, id, divergeData, log, scope, componentFromModel);
     if (modifiedComp) {
-      consumer.scope.objects.add(modifiedComp);
-      const modelComponent = await consumer.scope.getModelComponent(id);
-      const versionHistory = await modelComponent.updateRebasedVersionHistory(consumer.scope.objects, [modifiedComp]);
-      if (versionHistory) consumer.scope.objects.add(versionHistory);
+      scope.objects.add(modifiedComp);
+      const modelComponent = await scope.getModelComponent(id);
+      const versionHistory = await modelComponent.updateRebasedVersionHistory(scope.objects, [modifiedComp]);
+      if (versionHistory) scope.objects.add(versionHistory);
     }
   }));
 }