fix: increase deploy preview polling and cancel on unmount

With editorial workflow, saving remounts the EditorToolbar component
(navigates to the unpublished entry view), making componentDidMount
the primary polling trigger rather than componentDidUpdate.

The previous default of 3 attempts (15s) was too short for CI
pipelines to finish building and posting a commit status.

Changes:
- Increase componentDidMount polling to 24 attempts (~2 min)
- Cancel in-flight polling on component unmount via AbortSignal
- Cancel previous poll before starting a new one on subsequent saves
- Thread AbortSignal through action creator to backend polling loop
- Add 5 tests for polling behavior and cancellation

Author: jonasbeck

packages/decap-cms-core/src/actions/deploys.ts

@@ -55,16 +55,17 @@ export function loadDeployPreview(
   slug: string,
   entry: Entry,
   published: boolean,
-  opts?: { maxAttempts?: number; interval?: number },
+  opts?: { maxAttempts?: number; interval?: number; signal?: AbortSignal },
 ) {
   return async (dispatch: ThunkDispatch<State, undefined, AnyAction>, getState: () => State) => {
     const state = getState();
     const backend = currentBackend(state.config);
     const collectionName = collection.get('name');
 
-    // Exit if currently fetching
+    // Exit if currently fetching, unless the caller provides a signal
+    // (indicating it manages cancellation of the previous poll externally).
     const deployState = selectDeployPreview(state, collectionName, slug);
-    if (deployState && deployState.isFetching) {
+    if (deployState && deployState.isFetching && !opts?.signal) {
       return;
     }
 

packages/decap-cms-core/src/backend.ts

@@ -1046,7 +1046,11 @@ export class Backend {
     collection: Collection,
     slug: string,
     entry: EntryMap,
-    { maxAttempts = 1, interval = 5000 } = {},
+    {
+      maxAttempts = 1,
+      interval = 5000,
+      signal,
+    }: { maxAttempts?: number; interval?: number; signal?: AbortSignal } = {},
   ) {
     /**
      * If the registered backend does not provide a `getDeployPreview` method, or
@@ -1063,6 +1067,9 @@ export class Backend {
     let deployPreview,
       count = 0;
     while (!deployPreview && count < maxAttempts) {
+      if (signal?.aborted) {
+        return;
+      }
       count++;
       deployPreview = await this.implementation.getDeployPreview(collection.get('name'), slug);
       if (!deployPreview) {

packages/decap-cms-core/src/components/Editor/EditorToolbar.js

@@ -303,17 +303,32 @@ export class EditorToolbar extends React.Component {
 
     const { isNewEntry, loadDeployPreview } = this.props;
     if (!isNewEntry) {
-      loadDeployPreview({ maxAttempts: 3 });
+      // 24 attempts × 5s interval = ~2 min polling window.
+      // With editorial workflow, saving remounts the component (navigates to
+      // the unpublished entry view), so componentDidMount is the primary
+      // polling trigger — not componentDidUpdate.
+      this._pollController = new AbortController();
+      loadDeployPreview({ maxAttempts: 24, signal: this._pollController.signal });
     }
   }
 
   componentDidUpdate(prevProps) {
     const { isNewEntry, isPersisting, loadDeployPreview } = this.props;
     if (!isNewEntry && prevProps.isPersisting && !isPersisting) {
-      loadDeployPreview({ maxAttempts: 3 });
+      // Abort any in-flight poll before starting a new one.
+      this._pollController?.abort();
+      this._pollController = new AbortController();
+      // Fires on subsequent saves when the component survives (no remount).
+      // In editorial workflow the first save remounts, so this mainly
+      // covers the second-save-and-beyond case.
+      loadDeployPreview({ maxAttempts: 3, signal: this._pollController.signal });
     }
   }
 
+  componentWillUnmount() {
+    this._pollController?.abort();
+  }
+
   renderSimpleControls = () => {
     const { collection, hasChanged, isNewEntry, showDelete, onDelete, t } = this.props;
     const canCreate = collection.get('create');

packages/decap-cms-core/src/components/Editor/__tests__/EditorToolbar.spec.js

@@ -117,4 +117,50 @@ describe('EditorToolbar', () => {
       expect(asFragment()).toMatchSnapshot();
     });
   });
+
+  describe('deploy preview polling', () => {
+    it('should poll with maxAttempts: 24 and an AbortSignal on mount for existing entries', () => {
+      render(<EditorToolbar {...props} isNewEntry={false} />);
+      expect(props.loadDeployPreview).toHaveBeenCalledTimes(1);
+      const opts = props.loadDeployPreview.mock.calls[0][0];
+      expect(opts.maxAttempts).toBe(24);
+      expect(opts.signal).toBeInstanceOf(AbortSignal);
+    });
+
+    it('should not poll on mount for new entries', () => {
+      render(<EditorToolbar {...props} isNewEntry={true} />);
+      expect(props.loadDeployPreview).not.toHaveBeenCalled();
+    });
+
+    it('should poll with maxAttempts: 3 after a save completes', () => {
+      const { rerender } = render(<EditorToolbar {...props} isPersisting={true} />);
+      props.loadDeployPreview.mockClear();
+      rerender(<EditorToolbar {...props} isPersisting={false} />);
+      expect(props.loadDeployPreview).toHaveBeenCalledTimes(1);
+      const opts = props.loadDeployPreview.mock.calls[0][0];
+      expect(opts.maxAttempts).toBe(3);
+      expect(opts.signal).toBeInstanceOf(AbortSignal);
+    });
+
+    it('should abort polling on unmount', () => {
+      const { unmount } = render(<EditorToolbar {...props} isNewEntry={false} />);
+      const signal = props.loadDeployPreview.mock.calls[0][0].signal;
+      expect(signal.aborted).toBe(false);
+      unmount();
+      expect(signal.aborted).toBe(true);
+    });
+
+    it('should abort previous poll when a new save triggers a new poll', () => {
+      const { rerender } = render(<EditorToolbar {...props} isPersisting={false} />);
+      const firstSignal = props.loadDeployPreview.mock.calls[0][0].signal;
+
+      // Simulate save completing
+      rerender(<EditorToolbar {...props} isPersisting={true} />);
+      rerender(<EditorToolbar {...props} isPersisting={false} />);
+
+      expect(firstSignal.aborted).toBe(true);
+      const secondSignal = props.loadDeployPreview.mock.calls[1][0].signal;
+      expect(secondSignal.aborted).toBe(false);
+    });
+  });
 });