@teambit/merge-lanes 1.0.240 → 1.0.241

package/dist/merge-lane.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/merge-lane.spec.js

@@ -0,0 +1,111 @@
+"use strict";
+
+function _chai() {
+  const data = require("chai");
+  _chai = function () {
+    return data;
+  };
+  return data;
+}
+function _harmonyTesting() {
+  const data = require("@teambit/harmony.testing.load-aspect");
+  _harmonyTesting = function () {
+    return data;
+  };
+  return data;
+}
+function _workspaceTesting() {
+  const data = require("@teambit/workspace.testing.mock-workspace");
+  _workspaceTesting = function () {
+    return data;
+  };
+  return data;
+}
+function _scope() {
+  const data = require("@teambit/scope");
+  _scope = function () {
+    return data;
+  };
+  return data;
+}
+function _export() {
+  const data = require("@teambit/export");
+  _export = function () {
+    return data;
+  };
+  return data;
+}
+function _componentTesting() {
+  const data = require("@teambit/component.testing.mock-components");
+  _componentTesting = function () {
+    return data;
+  };
+  return data;
+}
+function _mergeLanes() {
+  const data = require("./merge-lanes.aspect");
+  _mergeLanes = function () {
+    return data;
+  };
+  return data;
+}
+function _lanes() {
+  const data = _interopRequireDefault(require("@teambit/lanes"));
+  _lanes = function () {
+    return data;
+  };
+  return data;
+}
+function _snapping() {
+  const data = _interopRequireDefault(require("@teambit/snapping"));
+  _snapping = function () {
+    return data;
+  };
+  return data;
+}
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+describe('MergeLane aspect', function () {
+  this.timeout(0);
+  describe('snap from scope an existing component with newDependencies prop populated', () => {
+    let workspaceData;
+    let harmonyBareScope;
+    let results;
+    before(async () => {
+      workspaceData = (0, _workspaceTesting().mockWorkspace)();
+      const {
+        workspacePath
+      } = workspaceData;
+      await (0, _componentTesting().mockComponents)(workspacePath, {
+        numOfComponents: 2
+      });
+      const harmony = await (0, _harmonyTesting().loadManyAspects)([_snapping().default, _export().ExportAspect, _lanes().default], workspacePath);
+      const lane = harmony.get(_lanes().default.id);
+      await lane.createLane('dev');
+      const snapping = harmony.get(_snapping().default.id);
+      await snapping.snap({
+        build: false,
+        message: 'first snap'
+      });
+      const exportMain = harmony.get(_export().ExportAspect.id);
+      await exportMain.export();
+      const bareScope = (0, _workspaceTesting().mockBareScope)(workspaceData.remoteScopePath, '-bare');
+      harmonyBareScope = await (0, _harmonyTesting().loadManyAspects)([_mergeLanes().MergeLanesAspect, _scope().ScopeAspect], bareScope.scopePath);
+      const mergeLaneMain = harmonyBareScope.get(_mergeLanes().MergeLanesAspect.id);
+      const remoteScopeName = workspaceData.remoteScopeName;
+      results = await mergeLaneMain.mergeFromScope(`${remoteScopeName}/dev`, 'main', {
+        pattern: `${remoteScopeName}/comp2`
+      });
+    });
+    it('should merge successfully the specified pattern only', async () => {
+      (0, _chai().expect)(results.mergedNow).to.have.lengthOf(1);
+      (0, _chai().expect)(results.mergedNow[0].fullName).to.equal('comp2');
+      (0, _chai().expect)(results.unmerged).to.have.lengthOf(1);
+      (0, _chai().expect)(results.unmerged[0].id.name).to.equal('comp1');
+    });
+    after(async () => {
+      await (0, _workspaceTesting().destroyWorkspace)(workspaceData);
+    });
+  });
+});
+
+//# sourceMappingURL=merge-lane.spec.js.map

package/dist/merge-lane.spec.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["_chai","data","require","_harmonyTesting","_workspaceTesting","_scope","_export","_componentTesting","_mergeLanes","_lanes","_interopRequireDefault","_snapping","obj","__esModule","default","describe","timeout","workspaceData","harmonyBareScope","results","before","mockWorkspace","workspacePath","mockComponents","numOfComponents","harmony","loadManyAspects","SnappingAspect","ExportAspect","LanesAspect","lane","get","id","createLane","snapping","snap","build","message","exportMain","export","bareScope","mockBareScope","remoteScopePath","MergeLanesAspect","ScopeAspect","scopePath","mergeLaneMain","remoteScopeName","mergeFromScope","pattern","it","expect","mergedNow","to","have","lengthOf","fullName","equal","unmerged","name","after","destroyWorkspace"],"sources":["merge-lane.spec.ts"],"sourcesContent":["import { expect } from 'chai';\nimport { Harmony } from '@teambit/harmony';\nimport { loadManyAspects } from '@teambit/harmony.testing.load-aspect';\nimport {\n  mockWorkspace,\n  mockBareScope,\n  destroyWorkspace,\n  WorkspaceData,\n} from '@teambit/workspace.testing.mock-workspace';\nimport { ScopeAspect } from '@teambit/scope';\nimport { ExportAspect, ExportMain } from '@teambit/export';\nimport { mockComponents } from '@teambit/component.testing.mock-components';\nimport { MergeLanesAspect } from './merge-lanes.aspect';\nimport { MergeFromScopeResult, MergeLanesMain } from './merge-lanes.main.runtime';\nimport LanesAspect, { LanesMain } from '@teambit/lanes';\nimport SnappingAspect, { SnappingMain } from '@teambit/snapping';\n\ndescribe('MergeLane aspect', function () {\n  this.timeout(0);\n\n  describe('snap from scope an existing component with newDependencies prop populated', () => {\n    let workspaceData: WorkspaceData;\n    let harmonyBareScope: Harmony;\n    let results: MergeFromScopeResult;\n    before(async () => {\n      workspaceData = mockWorkspace();\n      const { workspacePath } = workspaceData;\n      await mockComponents(workspacePath, { numOfComponents: 2 });\n      const harmony = await loadManyAspects([SnappingAspect, ExportAspect, LanesAspect], workspacePath);\n      const lane = harmony.get<LanesMain>(LanesAspect.id);\n      await lane.createLane('dev');\n      const snapping = harmony.get<SnappingMain>(SnappingAspect.id);\n      await snapping.snap({ build: false, message: 'first snap' });\n      const exportMain = harmony.get<ExportMain>(ExportAspect.id);\n      await exportMain.export();\n\n      const bareScope = mockBareScope(workspaceData.remoteScopePath, '-bare');\n      harmonyBareScope = await loadManyAspects([MergeLanesAspect, ScopeAspect], bareScope.scopePath);\n      const mergeLaneMain = harmonyBareScope.get<MergeLanesMain>(MergeLanesAspect.id);\n      const remoteScopeName = workspaceData.remoteScopeName;\n      results = await mergeLaneMain.mergeFromScope(`${remoteScopeName}/dev`, 'main', {\n        pattern: `${remoteScopeName}/comp2`,\n      });\n    });\n    it('should merge successfully the specified pattern only', async () => {\n      expect(results.mergedNow).to.have.lengthOf(1);\n      expect(results.mergedNow[0].fullName).to.equal('comp2');\n      expect(results.unmerged).to.have.lengthOf(1);\n      expect(results.unmerged[0].id.name).to.equal('comp1');\n    });\n    after(async () => {\n      await destroyWorkspace(workspaceData);\n    });\n  });\n});\n"],"mappings":"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","ignoreList":[]}

package/dist/merge-lanes.main.runtime.d.ts

@@ -34,6 +34,13 @@ export type MergeLaneOptions = {
     skipFetch?: boolean;
     excludeNonLaneComps?: boolean;
     shouldIncludeUpdateDependents?: boolean;
+    throwIfNotUpToDate?: boolean;
+    fetchCurrent?: boolean;
+};
+export type ConflictPerId = {
+    id: ComponentID;
+    files: string[];
+    config?: boolean;
 };
 export type MergeFromScopeResult = {
     mergedNow: ComponentID[];
@@ -42,11 +49,7 @@ export type MergeFromScopeResult = {
         id: ComponentID;
         reason: string;
     }[];
-    conflicts?: Array<{
-        id: ComponentID;
-        files: string[];
-        config?: boolean;
-    }>;
+    conflicts?: ConflictPerId[];
     snappedIds?: ComponentID[];
     mergedPreviously: ComponentID[];
     mergeSnapError?: Error;
@@ -66,11 +69,15 @@ export declare class MergeLanesMain {
         mergeResults: ApplyVersionResults;
         deleteResults: any;
         configMergeResults: ConfigMergeResult[];
+        mergedSuccessfullyIds: ComponentID[];
+        conflicts: ConflictPerId[];
     }>;
     mergeLane(otherLaneId: LaneId, currentLaneId: LaneId, options: MergeLaneOptions): Promise<{
         mergeResults: ApplyVersionResults;
         deleteResults: any;
         configMergeResults: ConfigMergeResult[];
+        mergedSuccessfullyIds: ComponentID[];
+        conflicts: ConflictPerId[];
     }>;
     abortLaneMerge(checkoutProps: CheckoutProps, mergeAbortOpts: MergeAbortOpts): Promise<{
         checkoutResults: ApplyVersionResults | undefined;

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

@@ -226,7 +226,9 @@ class MergeLanesMain {
       ignoreConfigChanges,
       skipFetch,
       excludeNonLaneComps,
-      shouldIncludeUpdateDependents
+      shouldIncludeUpdateDependents,
+      throwIfNotUpToDate,
+      fetchCurrent
     } = options;
     const legacyScope = this.scope.legacyScope;
     if (tag && !currentLaneId.isDefault()) {
@@ -238,6 +240,10 @@ class MergeLanesMain {
     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"`);
     }
+    if (fetchCurrent && !currentLaneId.isDefault()) {
+      // if current is default, it'll be fetch later on
+      await this.lanes.fetchLaneWithItsComponents(currentLaneId);
+    }
     const currentLane = currentLaneId.isDefault() ? null : await legacyScope.loadLane(currentLaneId);
     const isDefaultLane = otherLaneId.isDefault();
     if (isDefaultLane) {
@@ -253,16 +259,21 @@ class MergeLanesMain {
       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);
+        const otherLane = await this.lanes.fetchLaneWithItsComponents(otherLaneId, shouldIncludeUpdateDependents);
         laneToFetchArtifactsFrom = otherLane;
         lane = await legacyScope.loadLane(otherLaneId);
       }
       return lane;
     };
     const otherLane = isDefaultLane ? undefined : await getOtherLane();
+    if (fetchCurrent && otherLane && currentLaneId.isDefault()) {
+      const ids = await this.getMainIdsToMerge(otherLane, false, shouldIncludeUpdateDependents);
+      const compIdList = _componentId().ComponentIdList.fromArray(ids).toVersionLatest();
+      await this.importer.importObjectsFromMainIfExist(compIdList);
+    }
     const getBitIds = async () => {
       if (isDefaultLane) {
-        const ids = await this.getMainIdsToMerge(currentLane, !excludeNonLaneComps);
+        const ids = await this.getMainIdsToMerge(currentLane, !excludeNonLaneComps, shouldIncludeUpdateDependents);
         const modelComponents = await Promise.all(ids.map(id => this.scope.legacyScope.getModelComponent(id)));
         return (0, _lodash().compact)(modelComponents.map(c => {
           if (!c.head) return null; // probably the component was never merged to main
@@ -273,6 +284,7 @@ class MergeLanesMain {
       return shouldIncludeUpdateDependents ? otherLane.toComponentIdsIncludeUpdateDependents() : otherLane.toComponentIds();
     };
     const idsToMerge = await getBitIds();
+    if (throwIfNotUpToDate) await this.throwIfNotUpToDate(otherLaneId, currentLaneId);
     this.logger.debug(`merging the following ids: ${idsToMerge.toString()}`);
     const shouldSquash = squash || currentLaneId.isDefault() && !noSquash;
     let allComponentsStatus = await this.merging.getMergeStatus(idsToMerge, {
@@ -310,8 +322,9 @@ class MergeLanesMain {
       });
     }
     (0, _checkout().throwForFailures)(allComponentsStatus);
+    const succeededComponents = allComponentsStatus.filter(c => !c.unchangedMessage);
     if (shouldSquash) {
-      await squashSnaps(allComponentsStatus, currentLaneId, otherLaneId, legacyScope, options.snapMessage);
+      await squashSnaps(succeededComponents, currentLaneId, otherLaneId, legacyScope, options.snapMessage);
     }
     if (laneToFetchArtifactsFrom) {
       const ids = allComponentsStatus.map(c => c.id);
@@ -343,12 +356,28 @@ class MergeLanesMain {
         readmeResult: ''
       };
     }
-    const configMergeResults = allComponentsStatus.map(c => c.configMergeResult);
+    const configMergeResults = (0, _lodash().compact)(allComponentsStatus.map(c => c.configMergeResult));
+    const componentsWithConfigConflicts = configMergeResults.filter(c => c.hasConflicts()).map(c => c.compIdStr);
+    const conflicts = [];
+    const mergedSuccessfullyIds = [];
+    mergeResults.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 mergedSuccessfullyIds.push(c.id);
+    });
     await this.workspace?.consumer.onDestroy(`lane-merge (${otherLaneId.name})`);
     return {
       mergeResults,
       deleteResults,
-      configMergeResults: (0, _lodash().compact)(configMergeResults)
+      configMergeResults,
+      mergedSuccessfullyIds,
+      conflicts
     };
   }
   async abortLaneMerge(checkoutProps, mergeAbortOpts) {
@@ -386,9 +415,9 @@ class MergeLanesMain {
       checkoutError
     };
   }
-  async getMainIdsToMerge(lane, includeNonLaneComps = true) {
+  async getMainIdsToMerge(lane, includeNonLaneComps = true, includeUpdateDependents = false) {
     if (!lane) throw new Error(`unable to merge ${_laneId().DEFAULT_LANE}, the current lane was not found`);
-    const laneIds = lane.toBitIds();
+    const laneIds = includeUpdateDependents ? lane.toComponentIdsIncludeUpdateDependents() : lane.toComponentIds();
     const ids = laneIds.filter(id => this.scope.isExported(id));
     if (includeNonLaneComps) {
       if (!this.workspace) {
@@ -405,42 +434,11 @@ class MergeLanesMain {
       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 = 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 shouldIncludeUpdateDependents = toLaneId.isDefault();
-    const fromLaneBitIds = shouldIncludeUpdateDependents ? fromLaneObj?.toComponentIdsIncludeUpdateDependents() : fromLaneObj?.toComponentIds();
-    const toLaneCompIds = toLaneObj?.toComponentIds();
-    const laneIds = fromLaneBitIds || toLaneCompIds; // one of them must be defined.
-    const getIdsToMerge = async () => {
-      if (!options.pattern) return laneIds;
-      const ids = await this.scope.filterIdsFromPoolIdsByPattern(options.pattern, laneIds);
-      return _componentId().ComponentIdList.fromArray(ids);
-    };
-    const idsToMerge = await getIdsToMerge();
-    const scopeComponentsImporter = this.scope.legacyScope.scopeImporter;
-    await scopeComponentsImporter.importWithoutDeps(idsToMerge.toVersionLatest(), {
-      cache: false,
-      lane: fromLaneObj,
-      ignoreMissingHead: true,
-      includeVersionHistory: true,
-      includeUpdateDependents: shouldIncludeUpdateDependents,
-      reason: `of "from" lane (${fromLaneId.name}) for lane-merge to get all version-history`
-    });
-
-    // get their main/to-lane as well
-    await scopeComponentsImporter.importWithoutDeps(idsToMerge.toVersionLatest(), {
-      cache: false,
-      lane: toLaneObj,
-      ignoreMissingHead: true,
-      includeVersionHistory: true,
-      reason: `of "to" lane (${toLaneId.name}) for lane-merge to get all version-history`
-    });
-    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 shouldSquash = toLaneId.isDefault() && !options.noSquash; // only when merging to main we squash.
       const compIdsList = _componentId().ComponentIdList.fromArray(idsToExport);
       const {
         exported
@@ -464,9 +462,6 @@ class MergeLanesMain {
       });
       return exported;
     };
-    if (!fromLaneId.isDefault()) {
-      await this.throwIfNotUpToDate(fromLaneId, toLaneId);
-    }
 
     // current -> target (to)
     // other -> source (from)
@@ -474,39 +469,28 @@ class MergeLanesMain {
     options.excludeNonLaneComps = true;
     options.skipDependencyInstallation = true;
     options.shouldIncludeUpdateDependents = shouldIncludeUpdateDependents;
+    options.throwIfNotUpToDate = !fromLaneId.isDefault();
+    options.fetchCurrent = true;
     this.scope.legacyScope.setCurrentLaneId(toLaneId);
-    // this causes issues when merging main to a lane as it fetches from the lane instead of from main.
-    // see the e2e-test: "main to lane and multiple scopes when a main-version is missing from lane-scope"
-    // this.scope.legacyScope.scopeImporter.shouldOnlyFetchFromCurrentLane = true;
-
-    const result = await this.mergeLane(fromLaneId, toLaneId, options);
+    const {
+      mergeResults,
+      configMergeResults,
+      conflicts,
+      mergedSuccessfullyIds
+    } = await this.mergeLane(fromLaneId, toLaneId, options);
     const {
       mergeSnapResults,
-      leftUnresolvedConflicts,
       failedComponents,
-      components,
       mergeSnapError
-    } = 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);
-    });
+    } = mergeResults;
+    if (configMergeResults.length) {
+      this.logger.debug(`found the following config conflicts: ${configMergeResults.map(c => `\n${c.compIdStr}\n${c.generateMergeConflictFile()}`).join('\n')}`);
+    }
     const snappedIds = mergeSnapResults?.snappedComponents.map(c => c.id) || [];
     const laneToExport = toLaneId.isDefault() ? undefined : await this.lanes.loadLane(toLaneId); // needs to be loaded again after the merge as it changed
-    const exportedIds = leftUnresolvedConflicts || mergeSnapError ? [] : await exportIfNeeded(idsToMerge.map(id => id.changeVersion(undefined)), laneToExport || undefined);
+    const exportedIds = conflicts.length || mergeSnapError ? [] : await exportIfNeeded(mergedSuccessfullyIds.map(id => id.changeVersion(undefined)), laneToExport || undefined);
     return {
-      mergedNow: merged,
+      mergedNow: mergedSuccessfullyIds,
       mergedPreviously: failedComponents?.filter(({
         unchangedMessage
       }) => unchangedMessage === _merging().compIsAlreadyMergedMsg).map(c => c.id) || [],
@@ -661,9 +645,8 @@ async function getLogForSquash(otherLaneId) {
   });
   return log;
 }
-async function squashSnaps(allComponentsStatus, currentLaneId, otherLaneId, scope, messageTitle) {
+async function squashSnaps(succeededComponents, currentLaneId, otherLaneId, scope, messageTitle) {
   const currentLaneName = currentLaneId.name;
-  const succeededComponents = allComponentsStatus.filter(c => !c.unchangedMessage);
   const log = await getLogForSquash(otherLaneId);
   await Promise.all(succeededComponents.map(async ({
     id,