feat(davinci-client): mfa otp field support

Author: cerebrl

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

@@ -28,6 +28,7 @@ import type {
   SingleValueCollectors,
   IdpCollector,
   MultiSelectCollector,
+  ObjectValueCollectors,
 } from './collector.types.js';
 import type { InitFlow, Updater, Validator } from './client.types.js';
 import { returnValidator } from './collector.utils.js';
@@ -167,7 +168,9 @@ export async function davinci<ActionType extends ActionTypes = ActionTypes>({
      * @param {SingleValueCollector} collector - the collector to update
      * @returns {function} - a function to call for updating collector value
      */
-    update: (collector: SingleValueCollectors | MultiSelectCollector): Updater => {
+    update: (
+      collector: SingleValueCollectors | MultiSelectCollector | ObjectValueCollectors,
+    ): Updater => {
       if (!collector.id) {
         console.error('Argument for `collector` has no ID');
         return function () {
@@ -197,7 +200,8 @@ export async function davinci<ActionType extends ActionTypes = ActionTypes>({
       if (
         collectorToUpdate.category !== 'MultiValueCollector' &&
         collectorToUpdate.category !== 'SingleValueCollector' &&
-        collectorToUpdate.category !== 'ValidatedSingleValueCollector'
+        collectorToUpdate.category !== 'ValidatedSingleValueCollector' &&
+        collectorToUpdate.category !== 'ObjectValueCollector'
       ) {
         console.error(
           'Collector is not a MultiValueCollector, SingleValueCollector or ValidatedSingleValueCollector and cannot be updated',

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

@@ -4,6 +4,7 @@
  * This software may be modified and distributed under the terms
  * of the MIT license. See the LICENSE file for details.
  */
+
 /** *********************************************************************
  * SINGLE-VALUE COLLECTORS
  */
@@ -15,10 +16,11 @@ export type SingleValueCollectorTypes =
   | 'PasswordCollector'
   | 'SingleValueCollector'
   | 'SingleSelectCollector'
+  | 'SingleSelectObjectCollector'
   | 'TextCollector'
   | 'ValidatedTextCollector';
 
-interface SelectorOptions {
+interface SelectorOption {
   label: string;
   value: string;
 }
@@ -90,7 +92,7 @@ export interface SingleSelectCollectorWithValue<T extends SingleValueCollectorTy
     label: string;
     type: string;
     value: string | number | boolean;
-    options: SelectorOptions[];
+    options: SelectorOption[];
   };
 }
 
@@ -127,7 +129,7 @@ export interface SingleSelectCollectorNoValue<T extends SingleValueCollectorType
     key: string;
     label: string;
     type: string;
-    options: SelectorOptions[];
+    options: SelectorOption[];
   };
 }
 
@@ -143,16 +145,18 @@ export type InferSingleValueCollectorType<T extends SingleValueCollectorTypes> =
     ? TextCollector
     : T extends 'SingleSelectCollector'
       ? SingleSelectCollector
-      : T extends 'PasswordCollector'
-        ? PasswordCollector
-        : /**
-           * At this point, we have not passed in a collector type
-           * or we have explicitly passed in 'SingleValueCollector'
-           * So we can return either a SingleValueCollector with value
-           * or without a value.
-           **/
-          | SingleValueCollectorWithValue<'SingleValueCollector'>
-            | SingleValueCollectorNoValue<'SingleValueCollector'>;
+      : T extends 'ValidatedTextCollector'
+        ? ValidatedTextCollector
+        : T extends 'PasswordCollector'
+          ? PasswordCollector
+          : /**
+             * At this point, we have not passed in a collector type
+             * or we have explicitly passed in 'SingleValueCollector'
+             * So we can return either a SingleValueCollector with value
+             * or without a value.
+             **/
+            | SingleValueCollectorWithValue<'SingleValueCollector'>
+              | SingleValueCollectorNoValue<'SingleValueCollector'>;
 
 /**
  * SINGLE-VALUE COLLECTOR TYPES
@@ -198,7 +202,7 @@ export interface MultiValueCollectorWithValue<T extends MultiValueCollectorTypes
     label: string;
     type: string;
     value: string[];
-    options: SelectorOptions[];
+    options: SelectorOption[];
   };
 }
 
@@ -218,7 +222,7 @@ export interface MultiValueCollectorNoValue<T extends MultiValueCollectorTypes>
     label: string;
     type: string;
     value: string[];
-    options: SelectorOptions[];
+    options: SelectorOption[];
   };
 }
 
@@ -246,6 +250,101 @@ export type MultiValueCollector<T extends MultiValueCollectorTypes> =
 
 export type MultiSelectCollector = MultiValueCollectorWithValue<'MultiSelectCollector'>;
 
+/** *********************************************************************
+ * OBJECT COLLECTORS
+ */
+
+export type ObjectValueCollectorTypes =
+  | 'DeviceAuthenticationCollector'
+  | 'DeviceRegistrationCollector'
+  | 'ObjectValueCollector'
+  | 'ObjectSelectCollector';
+
+interface ObjectOptionWithValue {
+  type: string;
+  label: string;
+  content: string;
+  default: boolean;
+  value: string;
+  key: string;
+}
+
+interface ObjectOptionNoValue {
+  type: string;
+  label: string;
+  content: string;
+  value: string;
+  key: string;
+}
+
+interface ObjectValue {
+  type: string;
+  id: string;
+  value: string;
+}
+
+export interface ObjectValueCollectorNoValue<T extends ObjectValueCollectorTypes> {
+  category: 'ObjectValueCollector';
+  error: string | null;
+  type: T;
+  id: string;
+  name: string;
+  input: {
+    key: string;
+    value: string | null;
+    type: string;
+  };
+  output: {
+    key: string;
+    label: string;
+    type: string;
+    options: ObjectOptionNoValue[];
+  };
+}
+
+export interface ObjectValueCollectorWithValue<T extends ObjectValueCollectorTypes> {
+  category: 'ObjectValueCollector';
+  error: string | null;
+  type: T;
+  id: string;
+  name: string;
+  input: {
+    key: string;
+    value: ObjectValue | null;
+    type: string;
+  };
+  output: {
+    key: string;
+    label: string;
+    type: string;
+    options: ObjectOptionWithValue[];
+  };
+}
+
+export type InferValueObjectCollectorType<T extends ObjectValueCollectorTypes> =
+  T extends 'DeviceAuthenticationCollector'
+    ? DeviceAuthenticationCollector
+    : T extends 'DeviceRegistrationCollector'
+      ? DeviceRegistrationCollector
+      :
+          | ObjectValueCollectorWithValue<'ObjectValueCollector'>
+          | ObjectValueCollectorNoValue<'ObjectValueCollector'>;
+
+export type ObjectValueCollectors =
+  | ObjectValueCollectorWithValue<'DeviceAuthenticationCollector'>
+  | ObjectValueCollectorNoValue<'DeviceRegistrationCollector'>
+  | ObjectValueCollectorWithValue<'ObjectSelectCollector'>
+  | ObjectValueCollectorNoValue<'ObjectSelectCollector'>;
+
+export type ObjectValueCollector<T extends ObjectValueCollectorTypes> =
+  | ObjectValueCollectorWithValue<T>
+  | ObjectValueCollectorNoValue<T>;
+
+export type DeviceRegistrationCollector =
+  ObjectValueCollectorNoValue<'DeviceRegistrationCollector'>;
+export type DeviceAuthenticationCollector =
+  ObjectValueCollectorWithValue<'DeviceAuthenticationCollector'>;
+
 /** *********************************************************************
  * ACTION COLLECTORS
  */

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

@@ -18,9 +18,12 @@ import {
   returnValidator,
   returnReadOnlyCollector,
   returnNoValueCollector,
+  returnObjectSelectCollector,
 } from './collector.utils.js';
 import type {
   DaVinciField,
+  DeviceAuthenticationFieldValue,
+  DeviceRegistrationFieldValue,
   ReadOnlyFieldValue,
   RedirectFieldValue,
   StandardFieldValue,
@@ -227,6 +230,12 @@ describe('Action Collectors', () => {
       });
     });
 
+    it('creates an action collector from flow link field type', () => {
+      const result = returnFlowCollector(mockField, 1);
+      expect(result.type).toBe('FlowCollector');
+      expect(result.output).not.toHaveProperty('value');
+    });
+
     it('handles missing authentication URL for social login', () => {
       const result = returnActionCollector(mockField, 1, 'IdpCollector');
       if ('url' in result.output) {
@@ -373,7 +382,11 @@ describe('Single Value Collectors', () => {
       expect(result.type).toBe('SingleSelectCollector');
       expect(result.output).toHaveProperty('value', '');
     });
+  });
+});
 
+describe('Multi-Value Collectors', () => {
+  describe('Specialized Multi-Select Collectors', () => {
     it('creates a multi-select collector from combobox field type', () => {
       const comboField: DaVinciField = {
         type: 'COMBOBOX',
@@ -396,11 +409,118 @@ describe('Single Value Collectors', () => {
       expect(result.type).toBe('MultiSelectCollector');
       expect(result.output).toHaveProperty('value', []);
     });
+  });
+});
 
-    it('creates an action collector from flow link field type', () => {
-      const result = returnFlowCollector(mockField, 1);
-      expect(result.type).toBe('FlowCollector');
-      expect(result.output).not.toHaveProperty('value');
+describe('Object value collectors', () => {
+  describe('returnDeviceAuthenticationCollector', () => {
+    const mockField: DeviceAuthenticationFieldValue = {
+      key: 'device-auth-key',
+      label: 'Device Authentication',
+      type: 'DEVICE_AUTHENTICATION',
+      devices: [
+        {
+          type: 'device1',
+          iconSrc: 'icon1.png',
+          title: 'Device 1',
+          id: '123123',
+          default: true,
+          value: 'device1-value',
+        },
+        {
+          type: 'device2',
+          iconSrc: 'icon2.png',
+          title: 'Device 2',
+          id: '345345',
+          default: false,
+          value: 'device2-value',
+        },
+      ],
+      required: true,
+    };
+
+    const transformedDevices = mockField.devices.map((device) => ({
+      label: device.title,
+      value: device.id,
+      content: device.value,
+      type: device.type,
+      key: device.id,
+      default: device.default,
+    }));
+
+    it('should create a valid DeviceAuthenticationCollector', () => {
+      const result = returnObjectSelectCollector(mockField, 1);
+      expect(result).toEqual({
+        category: 'ObjectValueCollector',
+        error: null,
+        type: 'DeviceAuthenticationCollector',
+        id: 'device-auth-key-1',
+        name: 'device-auth-key',
+        input: {
+          key: mockField.key,
+          value: null,
+          type: mockField.type,
+        },
+        output: {
+          key: mockField.key,
+          label: mockField.label,
+          type: mockField.type,
+          options: transformedDevices,
+        },
+      });
+    });
+  });
+
+  describe('returnDeviceRegistrationCollector', () => {
+    const mockField: DeviceRegistrationFieldValue = {
+      key: 'device-reg-key',
+      label: 'Device Registration',
+      type: 'DEVICE_REGISTRATION',
+      devices: [
+        {
+          type: 'device1',
+          iconSrc: 'icon1.png',
+          title: 'Device 1',
+          description: 'Device 1 Description',
+        },
+        {
+          type: 'device2',
+          iconSrc: 'icon2.png',
+          title: 'Device 2',
+          description: 'Device 2 Description',
+        },
+      ],
+      required: true,
+    };
+
+    const transformedDevices = mockField.devices.map((device, idx) => ({
+      label: device.title,
+      value: device.type,
+      content: device.description,
+      type: device.type,
+      key: `${device.type}-${idx}`,
+    }));
+
+    it('should create a valid DeviceRegistrationCollector', () => {
+      const result = returnObjectSelectCollector(mockField, 1);
+      expect(result).toEqual({
+        category: 'ObjectValueCollector',
+        error: null,
+        type: 'DeviceRegistrationCollector',
+        id: 'device-reg-key-1',
+        name: 'device-reg-key',
+        input: {
+          key: mockField.key,
+          value: null,
+          type: mockField.type,
+        },
+        output: {
+          key: mockField.key,
+          label: mockField.label,
+          type: mockField.type,
+          options: transformedDevices,
+        },
+      });
     });
   });
 });