chore(davinci-client): improve polling

Author: ancheetah

e2e/davinci-app/components/polling.ts

@@ -25,6 +25,8 @@ export default function pollingComponent(
   formEl.appendChild(button);
 
   button.onclick = async () => {
+    button.disabled = true;
+
     const p = document.createElement('p');
     p.innerText = 'Polling...';
     formEl?.appendChild(p);
@@ -54,5 +56,7 @@ export default function pollingComponent(
     formEl?.appendChild(resultEl);
 
     await submitForm();
+
+    button.disabled = false;
   };
 }

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

@@ -20,6 +20,9 @@ import { wellknownApi } from './wellknown.api.js';
 import type { InternalErrorResponse, PollingStatus } from './client.types.js';
 import { PollingCollector } from './collector.types.js';
 
+const isRecord = (value: unknown): value is Record<string, unknown> =>
+  typeof value === 'object' && value !== null;
+
 export function createClientStore<ActionType extends ActionTypes>({
   requestMiddleware,
   logger,
@@ -133,7 +136,8 @@ export async function handleChallengePolling({
         message: 'Not in a continue node state, must be in a continue node to use poll method',
         type: 'state_error',
       },
-    } as InternalErrorResponse;
+      type: 'internal_error',
+    };
   }
 
   // Construct the challenge polling endpoint
@@ -144,7 +148,8 @@ export async function handleChallengePolling({
         message: 'No self link found in server info for challenge polling operation',
         type: 'internal_error',
       },
-    } as InternalErrorResponse;
+      type: 'internal_error',
+    };
   }
 
   const selfUrl = links['self'].href;
@@ -160,7 +165,8 @@ export async function handleChallengePolling({
           'Failed to construct challenge polling endpoint. Requires host and environment ID.',
         type: 'parse_error',
       },
-    } as InternalErrorResponse;
+      type: 'internal_error',
+    };
   }
 
   const interactionId = serverSlice.interactionId;
@@ -170,7 +176,8 @@ export async function handleChallengePolling({
         message: 'Missing interactionId in server info for challenge polling',
         type: 'internal_error',
       },
-    } as InternalErrorResponse;
+      type: 'internal_error',
+    };
   }
 
   const challengeEndpoint = `${baseUrl}/${envId}/davinci/user/credentials/challenge/${challenge}/status`;
@@ -191,12 +198,10 @@ export async function handleChallengePolling({
 
   const challengePollµ = Micro.repeat(queryµ, {
     while: ({ data, error }) =>
-      retriesLeft > 0 && !error && !(data as Record<string, unknown>)['isChallengeComplete'],
+      retriesLeft > 0 && !error && isRecord(data) && !data['isChallengeComplete'],
     schedule: Micro.scheduleSpaced(pollInterval),
   }).pipe(
     Micro.flatMap(({ data, error }) => {
-      const pollResponse = data as Record<string, unknown>;
-
       // Check for any errors and return the appropriate status
       if (error) {
         // SerializedError
@@ -217,26 +222,35 @@ export async function handleChallengePolling({
         if ('status' in error) {
           status = error.status;
 
-          const errorDetails = error.data as Record<string, unknown>;
-          const serviceName = errorDetails['serviceName'];
+          if (isRecord(error.data)) {
+            const errorDetails = error.data as Record<string, unknown>;
+            const serviceName = errorDetails['serviceName'];
 
-          // Check for an expired challenge
-          if (status === 400 && serviceName && serviceName === 'challengeExpired') {
-            log.debug('Challenge expired for polling');
-            return Micro.succeed('expired' as PollingStatus);
-          } else {
-            // If we're here there is some other type of network error and status != 200
-            // e.g. A bad challenge can return a httpStatus of 400 with code 4019
-            log.debug('Network error occurred during polling');
-            return Micro.succeed('error' as PollingStatus);
+            // Check for an expired challenge
+            if (status === 400 && serviceName && serviceName === 'challengeExpired') {
+              log.debug('Challenge expired for polling');
+              return Micro.succeed('expired' as PollingStatus);
+            }
           }
+
+          // If we're here there is possibly some other type of network error and status != 200
+          // e.g. A bad challenge can return a httpStatus of 400 with code 4019
+          log.debug('Unknown error occurred during polling');
+          return Micro.succeed('error' as PollingStatus);
         }
       }
 
       // If a successful response is recieved it can be either a timeout or true success
+      if (!isRecord(data)) {
+        log.debug('Unable to parse polling response');
+        return Micro.succeed('error' as PollingStatus);
+      }
+      const pollResponse = data;
+
       if (pollResponse['isChallengeComplete'] === true) {
         const pollStatus = pollResponse['status'];
         if (!pollStatus) {
+          log.debug('Unable to determine polling status');
           return Micro.succeed('error' as PollingStatus);
         } else {
           return Micro.succeed(pollStatus as PollingStatus);

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

@@ -217,8 +217,8 @@ export type PollingField = {
   key: string;
   pollInterval: number;
   pollRetries: number;
-  pollChallengeStatus: boolean;
-  challenge: string;
+  pollChallengeStatus?: boolean;
+  challenge?: string;
 };
 
 export type UnknownField = Record<string, unknown>;

packages/davinci-client/src/lib/davinci.utils.test.ts

@@ -114,6 +114,102 @@ describe('transformSubmitRequest', () => {
     const result = transformSubmitRequest(node, logger({ level: 'none' }));
     expect(result).toEqual(expectedRequest);
   });
+
+  it('should set eventType to "submit" when PollingCollector exists but has no payload', () => {
+    const node: ContinueNode = {
+      cache: {
+        key: '123',
+      },
+      client: {
+        action: 'SIGNON',
+        collectors: [
+          {
+            category: 'SingleValueAutoCollector',
+            error: null,
+            type: 'PollingCollector',
+            id: 'polling-field-2',
+            name: 'polling-field',
+            input: {
+              key: 'polling-field',
+              value: '',
+              type: 'POLLING',
+            },
+            output: {
+              key: 'polling-field',
+              type: 'POLLING',
+              config: {
+                pollInterval: 2000,
+                pollRetries: 20,
+                pollChallengeStatus: true,
+                challenge: '123_456-7890',
+              },
+            },
+          },
+        ],
+        status: 'continue',
+      },
+      error: null,
+      httpStatus: 200,
+      server: {
+        id: '123',
+        eventName: 'login',
+        interactionId: '456',
+        status: 'continue',
+      },
+      status: 'continue',
+    };
+
+    const result = transformSubmitRequest(node, logger({ level: 'none' }));
+    expect(result.parameters.eventType).toBe('submit');
+  });
+
+  it('should set eventType to "polling" when PollingCollector has populated payload', () => {
+    const node: ContinueNode = {
+      cache: {
+        key: '123',
+      },
+      client: {
+        action: 'SIGNON',
+        collectors: [
+          {
+            category: 'SingleValueAutoCollector',
+            error: null,
+            type: 'PollingCollector',
+            id: 'polling-field-2',
+            name: 'polling-field',
+            input: {
+              key: 'polling-field',
+              value: 'complete',
+              type: 'POLLING',
+            },
+            output: {
+              key: 'polling-field',
+              type: 'POLLING',
+              config: {
+                pollInterval: 2000,
+                pollRetries: 20,
+                pollChallengeStatus: true,
+                challenge: '123_456-7890',
+              },
+            },
+          },
+        ],
+        status: 'continue',
+      },
+      error: null,
+      httpStatus: 200,
+      server: {
+        id: '123',
+        eventName: 'login',
+        interactionId: '456',
+        status: 'continue',
+      },
+      status: 'continue',
+    };
+
+    const result = transformSubmitRequest(node, logger({ level: 'none' }));
+    expect(result.parameters.eventType).toBe('polling');
+  });
 });
 
 describe('transformActionRequest', () => {

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

@@ -31,6 +31,7 @@ import {
 /**
  * @function transformSubmitRequest - Transforms a NextNode into a DaVinciRequest for form submissions
  * @param {ContinueNode} node - The node to transform into a DaVinciRequest
+ * @param {ReturnType<typeof loggerFn>} logger - Logger instance
  * @returns {DaVinciRequest} - The transformed request object
  */
 export function transformSubmitRequest(
@@ -63,10 +64,14 @@ export function transformSubmitRequest(
     return acc;
   }, {});
 
-  // Set eventType based on PollingCollector presence
-  const eventType = collectors?.some((collector) => collector.type === 'PollingCollector')
-    ? 'polling'
-    : 'submit';
+  // Determine eventType: check if there's a PollingCollector with a non-empty string value
+  const hasPollingWithPayload = collectors?.some(
+    (collector) =>
+      collector.type === 'PollingCollector' &&
+      typeof collector.input.value === 'string' &&
+      collector.input.value,
+  );
+  const eventType = hasPollingWithPayload ? 'polling' : 'submit';
 
   logger.debug('Transforming submit request', { node, formData });
 

packages/davinci-client/src/lib/node.reducer.ts

@@ -337,13 +337,21 @@ export const nodeCollectorReducer = createReducer(initialCollectorValues, (build
      * transformed to `'node/poll'` for the action type.
      */
     .addCase(pollCollectorValues, (state) => {
-      // For challenge polling, track and decrement retries when this reducer is called
+      // For continue polling, track and decrement retries when this reducer is called
       const pollCollector = state.find((collector) => collector.type === 'PollingCollector');
 
-      if (!pollCollector?.output.config.retriesRemaining) {
+      if (!pollCollector) {
         throw new Error('No poll collector found to update');
       }
 
+      if (pollCollector.output.config.retriesRemaining === undefined) {
+        throw new Error('Polling collector does not track retriesRemaining');
+      }
+
+      if (pollCollector.output.config.retriesRemaining <= 0) {
+        throw new Error('No poll retries left');
+      }
+
       pollCollector.output.config.retriesRemaining--;
     });
 });