@teambit/lanes 1.0.1191 → 1.0.1192

package/dist/lanes.main.runtime.js

@@ -87,6 +87,13 @@ function _laneId() {
   };
   return data;
 }
+function _legacy2() {
+  const data = require("@teambit/legacy.scope-api");
+  _legacy2 = function () {
+    return data;
+  };
+  return data;
+}
 function _bitError() {
   const data = require("@teambit/bit-error");
   _bitError = function () {
@@ -317,6 +324,11 @@ function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t =
 function _defineProperty(e, r, t) { return (r = _toPropertyKey(r)) in e ? Object.defineProperty(e, r, { value: t, enumerable: !0, configurable: !0, writable: !0 }) : e[r] = t, e; }
 function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == typeof i ? i : i + ""; }
 function _toPrimitive(t, r) { if ("object" != typeof t || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != typeof i) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); } /* eslint-disable max-lines */
+/**
+ * where the entries were read from. the remote lane is the source of truth, so anything else means the
+ * local lane object was used instead, and why.
+ */
+
 /** where the base was resolved from: `workspace` (already local) or `scope` (fetched from remote). */
 
 class LanesMain {
@@ -1429,24 +1441,123 @@ please create a new lane instead, which will include all components of this lane
   }
 
   /**
-   * default to remove all of them.
-   * returns true if the lane has changed
+   * the dependents Ripple CI cascaded onto a lane (hidden `lane.updateDependents` entries).
+   * the cascade producer runs on the remote, so the remote lane is the source of truth. the local lane
+   * object is used only when the remote lane can't be fetched (e.g. the lane was never exported).
    */
-  async removeUpdateDependents(laneId, ids) {
-    const lane = await this.loadLane(laneId);
-    if (!lane) throw new (_bitError().BitError)(`unable to find a lane ${laneId.toString()}`);
-    if (ids?.length) {
-      ids.forEach(id => lane.removeComponentFromUpdateDependentsIfExist(id));
-    } else {
-      lane.removeAllUpdateDependents();
+  async getLaneUpdateDependents(laneId) {
+    let remoteError;
+    const remoteLane = this.isLaneLocalOnly(laneId) ? undefined : await this.importLaneObject(laneId, false).catch(err => {
+      remoteError = err;
+      return undefined;
+    });
+    if (remoteLane) {
+      return {
+        laneId,
+        ids: remoteLane.updateDependents || [],
+        source: 'remote'
+      };
     }
-    if (lane.hasChanged) {
-      await this.scope.legacyScope.lanes.saveLane(lane, {
-        laneHistoryMsg: 'remove update-dependents'
-      });
-      return true;
+    const localLane = await this.loadLane(laneId);
+    if (!localLane) {
+      const reason = remoteError ? `, and fetching it from the remote failed: ${remoteError.message}` : '';
+      throw new (_bitError().BitError)(`lane "${laneId.toString()}" was not found locally${reason}`);
+    }
+    // no error means no fetch was attempted, i.e. the lane is local-only. LaneNotFound means the same
+    // thing from the remote's side: either way the remote has no lane to be the source of truth.
+    const source = !remoteError || remoteError instanceof _legacy2().LaneNotFound ? 'no-remote-lane' : 'remote-unavailable';
+    return {
+      laneId,
+      ids: localLane.updateDependents || [],
+      source,
+      remoteError: remoteError?.message
+    };
+  }
+
+  /**
+   * remove the dependents Ripple CI cascaded onto a lane.
+   * exporting a lane never removes hidden entries from the remote (the remote-side merge walks the
+   * incoming entries only), so the removal is done directly on the remote, the same way the cloud UI
+   * does. the local lane object is updated as well so it doesn't keep stale entries until the next
+   * import. a lane that was never exported is changed locally only.
+   */
+  async undoLaneUpdateDependents(laneId, ids) {
+    const current = await this.getLaneUpdateDependents(laneId);
+    if (current.source === 'remote-unavailable') {
+      // the remote is the source of truth for these entries. removing them locally while the remote keeps
+      // them would only be reverted by the next import, so fail instead of pretending it worked.
+      throw new (_bitError().BitError)(`unable to undo the cascaded updates of lane "${laneId.toString()}": the remote lane could not be fetched (${current.remoteError}). the remote is the source of truth for these entries, retry when it's reachable`);
     }
-    return false;
+    // the remote has no such lane, so there's nothing to remove there: change the local lane only
+    const remoteSkipped = current.source === 'no-remote-lane';
+    const removed = ids?.length ? current.ids.filter(id => ids.some(toRemove => toRemove.isEqualWithoutVersion(id))) : current.ids;
+    if (!removed.length) {
+      // nothing left to remove on the remote, but the local lane can still hold entries the remote already
+      // dropped - e.g. an earlier undo whose local save failed after the remote removal succeeded. reconcile
+      // them here so retrying the command fixes it, instead of the stale entries lingering until the next import.
+      const localChanged = remoteSkipped ? false : await this.pruneStaleUpdateDependents(laneId, current.ids);
+      return {
+        laneId,
+        removed,
+        remoteChanged: false,
+        localChanged,
+        remoteSkipped
+      };
+    }
+    // remove exactly the resolved entries, on the remote and locally. this keeps local-only entries (e.g. a
+    // workspace cascade that wasn't exported yet) intact instead of wiping them with a remove-all.
+    const removedIdsStr = removed.map(id => id.toString());
+    let remoteChanged = false;
+    if (!remoteSkipped) {
+      const remote = await (0, _scope2().getRemoteByName)(laneId.scope, this.workspace?.consumer);
+      remoteChanged = await remote.removeLaneUpdateDependents(laneId.toString(), removedIdsStr);
+    }
+    const localLane = await this.loadLane(laneId);
+    // the local removal matches by component-id and not by the full versioned id on purpose. when a local
+    // cascade moved ahead of the remote, that entry is still for a component the user just undid: it can't
+    // be exported (the remote refuses new hidden entries without the override flag) and the next import
+    // prunes it anyway. keeping it would leave a hidden entry that "bit lane updates" no longer reports.
+    const localChanged = localLane ? await this.removeUpdateDependents(laneId, removed) : false;
+    return {
+      laneId,
+      removed,
+      remoteChanged,
+      localChanged,
+      remoteSkipped
+    };
+  }
+
+  /**
+   * remove local hidden entries whose component-id is absent from `remoteIds`, i.e. entries the remote has
+   * already dropped. matches by component-id and not by version, the same rule the import-side reconciliation
+   * in the lane merge uses, so a local cascade that only moved ahead of the remote survives.
+   * returns true if the local lane has changed.
+   */
+  async pruneStaleUpdateDependents(laneId, remoteIds) {
+    const localLane = await this.loadLane(laneId);
+    const localIds = localLane?.updateDependents;
+    if (!localIds?.length) return false;
+    const stale = localIds.filter(id => !remoteIds.some(remoteId => remoteId.isEqualWithoutVersion(id)));
+    if (!stale.length) return false;
+    return this.removeUpdateDependents(laneId, stale);
+  }
+
+  /**
+   * true when `laneId` is the current lane and it was never exported, i.e. it doesn't exist on the remote yet.
+   */
+  isLaneLocalOnly(laneId) {
+    if (!this.workspace) return false;
+    const currentLaneId = this.getCurrentLaneId();
+    if (!currentLaneId?.isEqual(laneId)) return false;
+    return !this.workspace.consumer.bitMap.isLaneExported;
+  }
+
+  /**
+   * default to remove all of them.
+   * returns true if the lane has changed
+   */
+  removeUpdateDependents(laneId, ids) {
+    return this.scope.legacyScope.lanes.removeUpdateDependents(laneId, ids);
   }
   async getLaneDataOfDefaultLane() {
     const consumer = this.workspace?.consumer;
@@ -1490,6 +1601,7 @@ please create a new lane instead, which will include all components of this lane
     laneCmd.commands.push(new (_lanesModules().LaneHistoryDiffCmd)(lanesMain, workspace, scope, componentCompare));
     laneCmd.commands.push(new (_lane().LaneCheckoutCmd)(lanesMain));
     laneCmd.commands.push(new (_lane().LaneRevertCmd)(lanesMain));
+    laneCmd.commands.push(new (_lane().LaneUpdatesCmd)(lanesMain));
     cli.register(laneCmd, switchCmd, new (_lane().CatLaneHistoryCmd)(lanesMain));
     cli.registerOnStart(async () => {
       await lanesMain.recreateNewLaneIfDeleted();