chore: do-actual-poll

Author: ryanbas21

e2e/davinci-app/components/polling.ts

@@ -4,54 +4,51 @@
  * This software may be modified and distributed under the terms
  * of the MIT license. See the LICENSE file for details.
  */
-import type { PollingCollector, Poller, Updater } from '@forgerock/davinci-client/types';
+import type {
+  InternalErrorResponse,
+  NodeStates,
+  PollingCollector,
+  Poller,
+} from '@forgerock/davinci-client/types';
+
+function isInternalErrorResponse(
+  value: NodeStates | InternalErrorResponse,
+): value is InternalErrorResponse {
+  return 'type' in value && value.type === 'internal_error';
+}
 
 export default function pollingComponent(
   formEl: HTMLFormElement,
   collector: PollingCollector,
   poll: Poller,
-  updater: Updater<PollingCollector>,
-  submitForm: () => Promise<void>,
+  onNode: (node: NodeStates) => void,
 ) {
   const button = document.createElement('button');
   button.type = 'button';
   button.value = collector.output.key;
-  button.innerHTML = 'Start polling';
+  button.textContent = 'Start polling';
   formEl.appendChild(button);
 
+  const controller = new AbortController();
+
   button.onclick = async () => {
     button.disabled = true;
 
-    const p = document.createElement('p');
-    p.innerText = 'Polling...';
-    formEl?.appendChild(p);
+    const status = document.createElement('p');
+    status.textContent = 'Polling...';
+    formEl.appendChild(status);
 
-    const status = await poll();
-    if (typeof status !== 'string' && 'error' in status) {
-      console.error(status.error?.message);
+    const result = await poll({ signal: controller.signal });
 
+    if (isInternalErrorResponse(result)) {
+      console.error(result.error?.message);
       const errEl = document.createElement('p');
-      errEl.innerText = 'Polling error: ' + status.error?.message;
-      formEl?.appendChild(errEl);
+      errEl.textContent = 'Polling error: ' + result.error?.message;
+      formEl.appendChild(errEl);
+      button.disabled = false;
       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;
-    }
-
-    const resultEl = document.createElement('p');
-    resultEl.innerText = 'Polling result: ' + JSON.stringify(status, null, 2);
-    formEl?.appendChild(resultEl);
-
-    await submitForm();
-
-    button.disabled = false;
+    onNode(result);
   };
 }

e2e/davinci-app/main.ts

@@ -271,8 +271,10 @@ const urlParams = new URLSearchParams(window.location.search);
           formEl, // You can ignore this; it's just for rendering
           collector, // This is the plain object of the collector
           davinciClient.poll(collector), // Returns a poll function
-          davinciClient.update(collector), // Returns an update function for this collector
-          submitForm,
+          (node) => {
+            if (node.status === 'success') renderComplete();
+            else renderForm();
+          },
         );
       } else if (collector.type === 'FlowCollector') {
         flowLinkComponent(

e2e/davinci-app/server-configs.ts

@@ -77,4 +77,16 @@ export const serverConfigs: Record<string, DaVinciConfig> = {
         'https://auth.pingone.ca/02fb4743-189a-4bc7-9d6c-a919edfe6447/as/.well-known/openid-configuration',
     },
   },
+  /**
+   * Polling
+   */
+  'ca0e8ba6-ad9f-4354-a778-d47fe8357ace': {
+    clientId: 'ca0e8ba6-ad9f-4354-a778-d47fe8357ace',
+    redirectUri: window.location.origin,
+    scope: 'openid profile email name revoke',
+    serverConfig: {
+      wellknown:
+        'https://auth.pingone.ca/02fb4743-189a-4bc7-9d6c-a919edfe6447/as/.well-known/openid-configuration',
+    },
+  },
 };

packages/davinci-client/src/lib/client.store.effects.ts

@@ -12,7 +12,7 @@ import { FetchBaseQueryError } from '@reduxjs/toolkit/query/react';
 import type { logger as loggerFn } from '@forgerock/sdk-logger';
 
 import type { ClientStore, RootState } from './client.store.utils.js';
-import type { PollingStatus, InternalErrorResponse } from './client.types.js';
+import type { NodeStates, PollingStatus, InternalErrorResponse } from './client.types.js';
 import type { PollingCollector } from './collector.types.js';
 
 import { createInternalError, isInternalError } from './client.store.utils.js';
@@ -227,9 +227,62 @@ export function interpretChallengeResponse(
   return 'timedOut';
 }
 
+/**
+ * Shape returned from one iteration of continue polling — the latest node and the
+ * next PollingCollector the server wants us to use (or null if the flow advanced).
+ */
+export interface PollingContinuation {
+  node: NodeStates;
+  nextPollingCollector: PollingCollector | null;
+}
+
+/**
+ * Pure snapshot of the current node and whether the server still wants polling.
+ * The caller decides whether to loop based on `nextPollingCollector`.
+ */
+export function evaluatePollingContinuation(rootState: RootState): PollingContinuation {
+  const node = nodeSlice.selectSlice(rootState);
+  const { state: collectors } = nodeSlice.selectors.selectCollectors(rootState);
+
+  let nextPollingCollector: PollingCollector | null = null;
+  for (const c of collectors ?? []) {
+    if (c.type === 'PollingCollector') {
+      nextPollingCollector = c;
+      break;
+    }
+  }
+
+  return { node, nextPollingCollector };
+}
+
+/**
+ * Stamps the PollingCollector's input.value, dispatches `next`, and resolves with
+ * the resulting NodeStates. The value is what `transformSubmitRequest` inspects to
+ * set `eventType: 'polling'` on the wire.
+ */
+function advanceFlowµ({
+  store,
+  collectorId,
+  pollingValue,
+}: {
+  store: ReturnType<ClientStore>;
+  collectorId: string;
+  pollingValue: string;
+}): Micro.Micro<NodeStates, InternalErrorResponse> {
+  return Micro.sync(() =>
+    store.dispatch(nodeSlice.actions.update({ id: collectorId, value: pollingValue })),
+  ).pipe(
+    Micro.flatMap(() =>
+      Micro.promise(() => store.dispatch(davinciApi.endpoints.next.initiate(undefined))),
+    ),
+    Micro.map(() => nodeSlice.selectSlice(store.getState())),
+  );
+}
+
 /**
  * Builds a Micro effect for the challenge polling branch.
- * validate → dispatch → repeat → interpret → lift errors
+ * validate → dispatch poll endpoint → repeat until complete → interpret →
+ * on terminal status, dispatch next and resolve with the resulting NodeStates.
  */
 function challengePollingµ({
   collector,
@@ -241,7 +294,7 @@ function challengePollingµ({
   challenge: string;
   store: ReturnType<ClientStore>;
   log: ReturnType<typeof loggerFn>;
-}): Micro.Micro<PollingStatus, InternalErrorResponse> {
+}): Micro.Micro<NodeStates, InternalErrorResponse> {
   const maxRetries = collector.output.config.pollRetries ?? 60;
   const pollInterval = collector.output.config.pollInterval ?? 2000;
 
@@ -263,24 +316,43 @@ function challengePollingµ({
       schedule: Micro.scheduleSpaced(pollInterval),
     }),
     Micro.map((response) => interpretChallengeResponse(response, log)),
-    Micro.flatMap((result) =>
-      isInternalError(result) ? Micro.fail(result) : Micro.succeed(result),
-    ),
+    Micro.flatMap((result): Micro.Micro<NodeStates, InternalErrorResponse> => {
+      if (isInternalError(result)) {
+        return Micro.fail(result);
+      }
+      if (result === 'timedOut' || result === 'error') {
+        return Micro.fail(createInternalError(`Challenge polling ${result}`, 'unknown_error'));
+      }
+      return advanceFlowµ({ store, collectorId: collector.id, pollingValue: result });
+    }),
   );
 }
 
 /**
  * Builds a Micro effect for the continue polling branch.
- * If retries remain, delays by pollInterval then returns 'continue'.
- * If retries are exhausted, returns 'timedOut' immediately.
+ * Each iteration: sleep → dispatch next → re-read state. Repeats while the server
+ * keeps returning a PollingCollector on a 'continue' node; stops once the flow advances.
  */
-function continuePollingµ(
-  mode: Extract<PollingMode, { _tag: 'continue' }>,
-): Micro.Micro<PollingStatus, InternalErrorResponse> {
-  if (mode.retriesRemaining <= 0) {
-    return Micro.succeed('timedOut' as PollingStatus);
-  }
-  return Micro.sleep(mode.pollInterval).pipe(Micro.map(() => 'continue'));
+function continuePollingµ({
+  collector,
+  store,
+}: {
+  collector: PollingCollector;
+  store: ReturnType<ClientStore>;
+}): Micro.Micro<NodeStates, InternalErrorResponse> {
+  const intervalMs = collector.output.config.pollInterval ?? 2000;
+
+  return Micro.sleep(intervalMs).pipe(
+    Micro.flatMap(() =>
+      advanceFlowµ({ store, collectorId: collector.id, pollingValue: 'continue' }),
+    ),
+    Micro.map(() => evaluatePollingContinuation(store.getState())),
+    Micro.repeat({
+      while: ({ node, nextPollingCollector }) =>
+        node.status === 'continue' && nextPollingCollector !== null,
+    }),
+    Micro.map(({ node }) => node),
+  );
 }
 
 /**
@@ -297,13 +369,13 @@ export function pollingµ({
   collector: PollingCollector;
   store: ReturnType<ClientStore>;
   log: ReturnType<typeof loggerFn>;
-}): Micro.Micro<PollingStatus, InternalErrorResponse> {
+}): Micro.Micro<NodeStates, InternalErrorResponse> {
   if (mode._tag === 'challenge') {
     return challengePollingµ({ collector, challenge: mode.challenge, store, log });
   }
 
   if (mode._tag === 'continue') {
-    return continuePollingµ(mode);
+    return continuePollingµ({ collector, store });
   }
 
   return Micro.fail(

packages/davinci-client/src/lib/client.store.ts

@@ -415,16 +415,17 @@ export async function davinci<ActionType extends ActionTypes = ActionTypes>({
     },
 
     /**
-     * @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
+     * @method poll - Drive a DaVinci polling flow end-to-end.
+     * Loops internally (sleep + dispatch `next`) until the server advances past
+     * the polling node, or until the challenge resolves, then returns the final node.
+     * Pass `{ signal }` to cancel an in-flight poll from the caller (e.g. on unmount).
      */
     poll: (collector: PollingCollector): Poller => {
-      return async () => {
+      return async ({ signal } = {}) => {
         const result = await getPollingModeµ(collector).pipe(
           Micro.flatMap((mode) => pollingµ({ mode, collector, store, log })),
           Micro.tapError((err) => Micro.sync(() => log.error(err.error.message))),
-          Micro.runPromiseExit,
+          (effect) => Micro.runPromiseExit(effect, { signal }),
         );
 
         if (exitIsSuccess(result)) {
@@ -435,10 +436,7 @@ export async function davinci<ActionType extends ActionTypes = ActionTypes>({
           return result.cause.error;
         }
 
-        return createInternalError(
-          'An unexpected error occurred during poll operation',
-          'unknown_error',
-        );
+        return createInternalError('Polling was cancelled', 'state_error');
       };
     },
 

packages/davinci-client/src/lib/client.types.ts

@@ -89,7 +89,9 @@ export type Validator = (value: string) =>
       };
       type: string;
     };
-export type Poller = () => Promise<PollingStatus | InternalErrorResponse>;
+export type Poller = (options?: {
+  signal?: AbortSignal;
+}) => Promise<NodeStates | InternalErrorResponse>;
 
 export type NodeStates = StartNode | ContinueNode | ErrorNode | SuccessNode | FailureNode;