feat(davinci-client): add continue polling support

ancheetah · ancheetah · commit 5429843a2053 · 2026-04-02T18:54:32.000-04:00
diff --git a/e2e/davinci-app/components/polling.ts b/e2e/davinci-app/components/polling.ts
@@ -4,17 +4,20 @@
  * This software may be modified and distributed under the terms
  * of the MIT license. See the LICENSE file for details.
  */
-import {
+import type {
   PollingCollector,
   PollingStatus,
   InternalErrorResponse,
   Updater,
+  ContinueNode,
 } from '@forgerock/davinci-client/types';
 
 export default function pollingComponent(
   formEl: HTMLFormElement,
   collector: PollingCollector,
-  poll: (collector: PollingCollector) => Promise<PollingStatus | InternalErrorResponse>,
+  poll: (
+    collector: PollingCollector,
+  ) => Promise<PollingStatus | ContinueNode | InternalErrorResponse>,
   updater: Updater<PollingCollector>,
   submitForm: () => Promise<void>,
 ) {
@@ -29,15 +32,24 @@ export default function pollingComponent(
     p.innerText = 'Polling...';
     formEl?.appendChild(p);
 
+    // TODO: support continue polling
     const status = await poll(collector);
     if (typeof status !== 'string' && 'error' in status) {
-      console.error(status.error.message);
+      console.error(status.error?.message);
+
+      const errEl = document.createElement('p');
+      errEl.innerText = 'Polling error: ' + status.error?.message;
+      formEl?.appendChild(errEl);
       return;
     }
 
     const result = updater(status);
     if (result && 'error' in result) {
       console.error(result.error.message);
+
+      const errEl = document.createElement('p');
+      errEl.innerText = 'Polling error: ' + result.error.message;
+      formEl?.appendChild(errEl);
       return;
     }
 
diff --git a/packages/davinci-client/src/lib/client.store.ts b/packages/davinci-client/src/lib/client.store.ts
@@ -14,6 +14,7 @@ import { isGenericError, createWellknownError } from '@forgerock/sdk-utilities';
 import {
   createClientStore,
   handleChallengePolling,
+  handleContinuePolling,
   handleUpdateValidateError,
   RootState,
 } from './client.store.utils.js';
@@ -413,8 +414,13 @@ export async function davinci<ActionType extends ActionTypes = ActionTypes>({
 
     /**
      * @method: poll - Poll for updates for a polling collector
+     * @returns {Promise<PollingStatus | ContinueNode | InternalErrorResponse>} - Returns a promise that resolves to
+     * a polling status or error for challenge polling. Returns a promise that resolves to the next node or
+     * an error for continue polling
      */
-    poll: async (collector: PollingCollector): Promise<PollingStatus | InternalErrorResponse> => {
+    poll: async (
+      collector: PollingCollector,
+    ): Promise<PollingStatus | ContinueNode | InternalErrorResponse> => {
       try {
         if (collector.type !== 'PollingCollector') {
           log.error('Collector provided to poll is not a PollingCollector');
@@ -427,19 +433,33 @@ export async function davinci<ActionType extends ActionTypes = ActionTypes>({
           };
         }
 
+        const pollChallengeStatus = collector.output.config.pollChallengeStatus;
         const challenge = collector.output.config.challenge;
 
-        // Challenge Polling
-        if (challenge) {
+        if (challenge && pollChallengeStatus === true) {
+          // Challenge Polling
           return await handleChallengePolling({
             collector,
             challenge,
             store,
             log,
           });
+        } else if (!challenge && !pollChallengeStatus) {
+          // Continue polling
+          return await handleContinuePolling({
+            collector,
+            store,
+            log,
+          });
         } else {
-          // TODO: Handle continue polling
-          return 'error' as PollingStatus;
+          log.error('Invalid polling collector configuration');
+          return {
+            error: {
+              message: 'Invalid polling collector configuration',
+              type: 'internal_error',
+            },
+            type: 'internal_error',
+          };
         }
       } catch (err) {
         const errorMessage = err instanceof Error ? err.message : String(err);
diff --git a/packages/davinci-client/src/lib/client.store.utils.ts b/packages/davinci-client/src/lib/client.store.utils.ts
@@ -183,8 +183,9 @@ export async function handleChallengePolling({
     retriesLeft--;
     return store.dispatch(
       davinciApi.endpoints.poll.initiate({
-        challengeEndpoint,
+        endpoint: challengeEndpoint,
         interactionId,
+        mode: 'challenge',
       }),
     );
   });
@@ -272,3 +273,190 @@ export async function handleChallengePolling({
     };
   }
 }
+
+export async function handleContinuePolling({
+  collector,
+  store,
+  log,
+}: {
+  collector: PollingCollector;
+  store: ReturnType<ClientStore>;
+  log: ReturnType<typeof loggerFn>;
+}): Promise<ContinueNode | InternalErrorResponse> {
+  const rootState: RootState = store.getState();
+  const serverSlice = nodeSlice.selectors.selectServer(rootState);
+
+  if (serverSlice === null) {
+    log.error('No server info found for poll operation');
+    return {
+      error: {
+        message: 'No server info found for poll operation',
+        type: 'state_error',
+      },
+      type: 'internal_error',
+    };
+  }
+
+  if (isGenericError(serverSlice)) {
+    log.error(serverSlice.message ?? serverSlice.error);
+    return {
+      error: {
+        message: serverSlice.message ?? 'Failed to retrieve server info for poll operation',
+        type: 'internal_error',
+      },
+      type: 'internal_error',
+    };
+  }
+
+  if (serverSlice.status !== 'continue') {
+    return {
+      error: {
+        message: 'Not in a continue node state, must be in a continue node to use poll method',
+        type: 'state_error',
+      },
+    } as InternalErrorResponse;
+  }
+
+  // Get the continue polling endpoint
+  const links = serverSlice._links;
+  if (!links || !('next' in links) || !('href' in links['next']) || !links['next'].href) {
+    return {
+      error: {
+        message: 'No next link found in server info for continue polling operation',
+        type: 'internal_error',
+      },
+    } as InternalErrorResponse;
+  }
+
+  const nextUrl = links['next'].href;
+
+  const interactionId = serverSlice.interactionId;
+  if (!interactionId) {
+    return {
+      error: {
+        message: 'Missing interactionId in server info for challenge polling',
+        type: 'internal_error',
+      },
+    } as InternalErrorResponse;
+  }
+
+  // Start continue polling
+  let retriesLeft = collector.output.config.pollRetries ?? 60;
+  const pollInterval = collector.output.config.pollInterval ?? 2000; // miliseconds
+
+  const updateµ = Micro.try({
+    try: () => {
+      // Update the polling collector input value to 'continue' or 'timedOut'. We will call
+      // continue polling endpoint (_links.next.href) with this data in queryµ
+      if (retriesLeft > 0) {
+        return store.dispatch(
+          nodeSlice.actions.update({ id: collector.id, value: 'continue' as PollingStatus }),
+        );
+      } else {
+        return store.dispatch(
+          nodeSlice.actions.update({ id: collector.id, value: 'timedOut' as PollingStatus }),
+        );
+      }
+    },
+    catch: (err) => {
+      const errorMessage = err instanceof Error ? err.message : String(err);
+      return {
+        type: 'internal_error',
+        error: { message: errorMessage, type: 'internal_error' },
+      } as InternalErrorResponse;
+    },
+  });
+
+  const queryµ = Micro.promise(() => {
+    retriesLeft--;
+    return store.dispatch(
+      davinciApi.endpoints.poll.initiate({
+        endpoint: nextUrl,
+        interactionId,
+        mode: 'continue',
+      }),
+    );
+  });
+
+  const repeatµ = updateµ.pipe(Micro.flatMap(() => queryµ));
+
+  const continuePollµ = Micro.repeat(repeatµ, {
+    while: ({ data, error }) =>
+      retriesLeft > 0 &&
+      !error &&
+      ['rewindStateToLastRenderedUI', 'rewindStateToSpecificRenderedUI'].includes(
+        (data as Record<string, unknown>)['eventName'] as string,
+      ),
+    schedule: Micro.scheduleSpaced(pollInterval),
+  }).pipe(
+    Micro.flatMap(({ data, error }) => {
+      const pollResponse = data as Record<string, unknown>;
+      console.log('Continue poll response', pollResponse);
+
+      if (error) {
+        // SerializedError
+        let message = 'An unknown error occurred while challenge polling';
+        if ('message' in error && error.message) {
+          message = error.message;
+          return Micro.fail({
+            error: {
+              message,
+              type: 'unknown_error',
+            },
+            type: 'internal_error',
+          } as InternalErrorResponse);
+        }
+
+        // FetchBaseQueryError
+        if ('status' in error) {
+          return Micro.fail({
+            error: {
+              message: 'An unknown error occured during continue polling',
+              type: 'unknown_error',
+            },
+            type: 'internal_error',
+          } as InternalErrorResponse);
+        }
+      }
+
+      if (retriesLeft <= 0) {
+        // Note: when retries are exhausted, DaVinci currently returns another continue polling response instead of an error
+        return Micro.fail({
+          error: {
+            message: 'Continue polling timed out',
+            type: 'internal_error',
+          },
+          type: 'internal_error',
+        } as InternalErrorResponse);
+      }
+
+      // TODO: If there are still retries left but we did not find a rewind event then polling succeeded and the next node was returned
+      // return the next node here
+
+      // Just in case no polling status was determined
+      return Micro.fail({
+        error: {
+          message: 'Unknown error occurred during continue polling',
+          type: 'unknown_error',
+        },
+        type: 'internal_error',
+      } as InternalErrorResponse);
+    }),
+  );
+
+  const result = await Micro.runPromiseExit(continuePollµ);
+
+  if (exitIsSuccess(result)) {
+    return result.value;
+  } else if (exitIsFail(result)) {
+    return result.cause.error;
+  } else {
+    return {
+      error: {
+        message: result.cause.message,
+        type: 'unknown_error',
+      },
+      type: 'internal_error',
+    };
+  }
+}
diff --git a/packages/davinci-client/src/lib/davinci.api.ts b/packages/davinci-client/src/lib/davinci.api.ts
@@ -437,19 +437,30 @@ export const davinciApi = createApi({
      * us to use the response from onQueryFn, while avoiding updating the node state with the poll
      * response which causes the node to lose the initial collectors state when polling started.
      */
-    poll: builder.mutation<unknown, { challengeEndpoint: string; interactionId: string }>({
-      async queryFn({ challengeEndpoint, interactionId }, api, _c, baseQuery) {
+    poll: builder.mutation<
+      unknown,
+      { endpoint: string; interactionId: string; mode: 'challenge' | 'continue' }
+    >({
+      async queryFn({ endpoint, interactionId, mode }, api, _c, baseQuery) {
+        const state = api.getState() as RootStateWithNode<ContinueNode>;
         const { requestMiddleware, logger } = api.extra as Extras;
 
+        let requestBody = {};
+        if (mode === 'continue') {
+          requestBody = transformSubmitRequest(state.node, logger);
+        } else if (mode !== 'challenge') {
+          logger.error('Invalid polling mode, defaulting to challenge mode');
+        }
+
         const request: FetchArgs = {
-          url: challengeEndpoint,
+          url: endpoint,
           credentials: 'include',
           method: 'POST',
           headers: {
             'Content-Type': 'application/json',
             interactionId,
           },
-          body: JSON.stringify({}),
+          body: JSON.stringify(requestBody),
         };
 
         logger.debug('Davinci API request', request);
