feat(davinci-client): add continue polling support

ancheetah · ancheetah · commit e5ad5834d477 · 2026-04-08T19:36:54.000-04:00
diff --git a/.github/actions/setup/action.yml b/.github/actions/setup/action.yml
@@ -31,7 +31,9 @@ runs:
         registry-url: 'https://registry.npmjs.org'
 
     - name: Update npm
-      run: npm install -g npm@latest
+      run: |
+        corepack enable
+        corepack install -g npm@latest
       shell: bash
 
     - name: Install dependencies
diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
@@ -32,7 +32,7 @@ jobs:
         with:
           CODECOV_TOKEN: ${{ secrets.CODECOV_TOKEN }}
 
-      - run: npx nx-cloud fix-ci
+      - run: pnpm nx fix-ci
         if: always()
 
       - uses: codecov/codecov-action@v5
diff --git a/e2e/davinci-app/components/polling.ts b/e2e/davinci-app/components/polling.ts
@@ -4,7 +4,7 @@
  * 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,
@@ -31,13 +31,21 @@ export default function pollingComponent(
 
     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
@@ -4,13 +4,14 @@
  * This software may be modified and distributed under the terms
  * of the MIT license. See the LICENSE file for details.
  */
-/**
- * Import RTK slices and api
- */
+import { Micro } from 'effect';
 import { CustomLogger, logger as loggerFn, LogLevel } from '@forgerock/sdk-logger';
 import { createStorage } from '@forgerock/storage';
 import { isGenericError, createWellknownError } from '@forgerock/sdk-utilities';
 
+/**
+ * Import RTK slices and api
+ */
 import {
   createClientStore,
   handleChallengePolling,
@@ -412,7 +413,9 @@ export async function davinci<ActionType extends ActionTypes = ActionTypes>({
     },
 
     /**
-     * @method: poll - Poll for updates for a polling collector
+     * @method poll - Perform challenge polling or continue polling
+     * @param {PollingCollector} collector - the polling collector
+     * @returns {Promise<PollingStatus | InternalErrorResponse>} - Returns a promise that resolves to a polling status or error
      */
     poll: async (collector: PollingCollector): Promise<PollingStatus | InternalErrorResponse> => {
       try {
@@ -427,19 +430,53 @@ 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
+          const retriesLeft = collector.output.config.retriesRemaining;
+          const pollInterval = collector.output.config.pollInterval ?? 2000; // miliseconds
+
+          if (retriesLeft === undefined) {
+            log.error('No retries found on PollingCollector');
+            return {
+              error: {
+                message: 'No retries found on PollingCollector',
+                type: 'argument_error',
+              },
+              type: 'internal_error',
+            };
+          }
+
+          if (retriesLeft > 0) {
+            const getStatusµ = Micro.sync(() => 'continue' as PollingStatus).pipe(
+              Micro.delay(pollInterval),
+            );
+            const status: PollingStatus = await Micro.runPromise(getStatusµ);
+            return status;
+          } else {
+            // Retries exhausted
+            return 'timedOut' as PollingStatus;
+          }
         } else {
-          // TODO: Handle continue polling
-          return 'error' as PollingStatus;
+          // Error if polling type can't be determined from configuration
+          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,7 +183,7 @@ export async function handleChallengePolling({
     retriesLeft--;
     return store.dispatch(
       davinciApi.endpoints.poll.initiate({
-        challengeEndpoint,
+        endpoint: challengeEndpoint,
         interactionId,
       }),
     );
diff --git a/packages/davinci-client/src/lib/client.types.ts b/packages/davinci-client/src/lib/client.types.ts
@@ -92,5 +92,11 @@ export type Validator = (value: string) =>
 
 export type NodeStates = StartNode | ContinueNode | ErrorNode | SuccessNode | FailureNode;
 
-export type PollingStatusComplete = 'approved' | 'denied' | 'continue' | string;
-export type PollingStatus = PollingStatusComplete | 'expired' | 'timedOut' | 'error';
+export type PollingStatusChallengeComplete = 'approved' | 'denied' | 'continue' | string;
+export type PollingStatusChallenge =
+  | PollingStatusChallengeComplete
+  | 'expired'
+  | 'timedOut'
+  | 'error';
+export type PollingStatusContinue = 'continue' | 'timedOut';
+export type PollingStatus = PollingStatusContinue | PollingStatusChallenge;
diff --git a/packages/davinci-client/src/lib/collector.types.ts b/packages/davinci-client/src/lib/collector.types.ts
@@ -588,6 +588,7 @@ export interface PollingOutputValue {
   pollRetries: number;
   pollChallengeStatus?: boolean;
   challenge?: string;
+  retriesRemaining?: number;
 }
 
 export type AutoCollectorCategories = 'SingleValueAutoCollector' | 'ObjectValueAutoCollector';
diff --git a/packages/davinci-client/src/lib/collector.utils.ts b/packages/davinci-client/src/lib/collector.utils.ts
@@ -326,6 +326,7 @@ export function returnSingleValueAutoCollector<
             pollChallengeStatus: field.pollChallengeStatus,
           }),
           ...(field.challenge && { challenge: field.challenge }),
+          ...(!field.challenge && { retriesRemaining: field.pollRetries }),
         },
       },
     } as InferAutoCollectorType<'PollingCollector'>;
diff --git a/packages/davinci-client/src/lib/davinci.api.ts b/packages/davinci-client/src/lib/davinci.api.ts
@@ -430,19 +430,19 @@ export const davinciApi = createApi({
     }),
 
     /**
-     * @method poll - method for polling in a DaVinci flow
+     * @method poll - method for challenge polling in a DaVinci flow
      */
     /**
      * The poll endpoint differs from others in that it does not use onQueryStarted. This allows
-     * us to use the response from onQueryFn, while avoiding updating the node state with the poll
+     * us to use the response from queryFn, 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 }>({
+      async queryFn({ endpoint, interactionId }, api, _c, baseQuery) {
         const { requestMiddleware, logger } = api.extra as Extras;
 
         const request: FetchArgs = {
-          url: challengeEndpoint,
+          url: endpoint,
           credentials: 'include',
           method: 'POST',
           headers: {
diff --git a/packages/davinci-client/src/lib/davinci.types.ts b/packages/davinci-client/src/lib/davinci.types.ts
@@ -264,6 +264,17 @@ export interface DaVinciNextResponse extends DaVinciBaseResponse {
   };
 }
 
+/**
+ * Continue Polling Response DaVinci API
+ */
+
+export interface DaVinciPollResponse extends DaVinciBaseResponse {
+  // Optional properties
+  eventName?: string;
+  success?: boolean;
+  _links?: Links;
+}
+
 /**
  * Error Response from DaVinci API
  */
diff --git a/packages/davinci-client/src/lib/davinci.utils.ts b/packages/davinci-client/src/lib/davinci.utils.ts
@@ -230,6 +230,7 @@ export function handleResponse(
    */
   if (cacheEntry.isSuccess) {
     const requestId = cacheEntry.requestId;
+
     const hasNextUrl = () => {
       const data = cacheEntry.data;
 
@@ -243,9 +244,19 @@ export function handleResponse(
       return false;
     };
 
+    const isContinuePollingEvent = () => {
+      const data = cacheEntry.data;
+      return (
+        'eventName' in data &&
+        ['rewindStateToLastRenderedUI', 'rewindStateToSpecificRenderedUI'].includes(data.eventName)
+      );
+    };
+
     if ('session' in cacheEntry.data || 'authorizeResponse' in cacheEntry.data) {
       const data = cacheEntry.data as DaVinciSuccessResponse;
       dispatch(nodeSlice.actions.success({ data, requestId, httpStatus: status }));
+    } else if (isContinuePollingEvent()) {
+      dispatch(nodeSlice.actions.poll({ requestId }));
     } else if (hasNextUrl()) {
       const data = cacheEntry.data as DaVinciNextResponse;
       dispatch(nodeSlice.actions.next({ data, requestId, httpStatus: status }));
diff --git a/packages/davinci-client/src/lib/node.reducer.ts b/packages/davinci-client/src/lib/node.reducer.ts
@@ -77,6 +77,7 @@ export const updateCollectorValues = createAction<{
     | FidoAuthenticationInputValue;
   index?: number;
 }>('node/update');
+export const pollCollectorValues = createAction('node/poll');
 
 /**
  * @const initialCollectorValues - Initial state for the collector values
@@ -329,5 +330,20 @@ export const nodeCollectorReducer = createReducer(initialCollectorValues, (build
         }
         collector.input.value = action.payload.value;
       }
+    })
+    /**
+     * Using the `pollCollectorValues` const (e.g. `'node/poll'`) to add the case
+     * 'node/poll' is essentially derived `createSlice` below. `node.poll()` is
+     * transformed to `'node/poll'` for the action type.
+     */
+    .addCase(pollCollectorValues, (state) => {
+      // For challenge polling, track and decrement retries when this reducer is called
+      const pollCollector = state.find((collector) => collector.type === 'PollingCollector');
+
+      if (!pollCollector?.output.config.retriesRemaining) {
+        throw new Error('No poll collector found to update');
+      }
+
+      pollCollector.output.config.retriesRemaining--;
     });
 });
diff --git a/packages/davinci-client/src/lib/node.slice.ts b/packages/davinci-client/src/lib/node.slice.ts
@@ -222,10 +222,11 @@ export const nodeSlice = createSlice({
 
       return newState;
     },
+
     /**
-     * @method start - Method for creating a start node
+     * @method success - Method for creating a success node
      * @param {Object} state - The current state of the slice
-     * @returns {StartNode} - The start node
+     * @returns {SuccessNode} - The success node
      */
     success(
       state,
@@ -264,6 +265,7 @@ export const nodeSlice = createSlice({
 
       return newState;
     },
+
     /**
      * @method update - Method for updating collector values with the node
      * @param {Object} state - The current state of the slice
@@ -277,6 +279,32 @@ export const nodeSlice = createSlice({
 
       return newState;
     },
+
+    /**
+     * @method poll - Method for creating the next node after continue polling
+     * @param {Object} state - The current state of the slice
+     * @param {PayloadAction} action - The action to be dispatched
+     * @returns {ContinueNode} - The next node
+     */
+    poll(
+      state,
+      action: PayloadAction<{
+        requestId: string;
+      }>,
+    ) {
+      const newState = state as Draft<ContinueNode>;
+
+      // Update retries remaining in poll collector
+      newState.client.collectors = nodeCollectorReducer(newState.client.collectors, action);
+
+      // Update cache key
+      newState.cache = {
+        key: action.payload.requestId,
+      };
+
+      // Return the previous continue node with updated retries and cache key
+      return newState;
+    },
   },
   selectors: {
     selectClient: (state) => {
diff --git a/packages/davinci-client/src/types.ts b/packages/davinci-client/src/types.ts
@@ -54,7 +54,6 @@ export type PollingCollector = collectors.PollingCollector;
 export type FidoRegistrationCollector = collectors.FidoRegistrationCollector;
 export type FidoAuthenticationCollector = collectors.FidoAuthenticationCollector;
 
-export type PollingStatusComplete = client.PollingStatusComplete;
 export type PollingStatus = client.PollingStatus;
 
 export type InternalErrorResponse = client.InternalErrorResponse;

Original file line number	Diff line number	Diff line change
`@@ -588,6 +588,7 @@ export interface PollingOutputValue {`
`588`	`588`	`pollRetries: number;`
`589`	`589`	`pollChallengeStatus?: boolean;`
`590`	`590`	`challenge?: string;`
	`591`	`+ retriesRemaining?: number;`
`591`	`592`	`}`
`592`	`593`
`593`	`594`	`export type AutoCollectorCategories = 'SingleValueAutoCollector' \| 'ObjectValueAutoCollector';`