feat(davinci-client): support Solution 3 root-level passwordPolicy fallback

Component-level policy takes precedence; falls back to root-level
passwordPolicy for backward compatibility during the migration period.

- Add passwordPolicy? to DaVinciNextResponse
- Thread root-level policy through node.slice → reducer → factory
- returnPasswordVerifyCollector prefers field.passwordPolicy ?? rootPasswordPolicy
- Add tests for fallback, precedence, and no-policy cases
- Restore root-level passwordPolicy in mock data (Solution 3 shape)

Author: ryanbas21

packages/davinci-client/api-report/davinci-client.api.md

@@ -1212,6 +1212,50 @@ describe('returnPasswordVerifyCollector', () => {
     expect(result.output).not.toHaveProperty('passwordPolicy');
   });
 
+  it('should fall back to root-level passwordPolicy when field has none', () => {
+    const field: PasswordVerifyField = {
+      type: 'PASSWORD_VERIFY',
+      key: 'user.password',
+      label: 'Password',
+    };
+    const rootPolicy = { id: 'root-policy', name: 'Root', length: { min: 6, max: 128 } };
+
+    const result = returnPasswordVerifyCollector(field, 0, rootPolicy);
+
+    expect(result.output.passwordPolicy).toEqual(rootPolicy);
+  });
+
+  it('should prefer component-level policy over root-level', () => {
+    const componentPolicy = {
+      id: 'component-policy',
+      name: 'Component',
+      length: { min: 8, max: 255 },
+    };
+    const rootPolicy = { id: 'root-policy', name: 'Root', length: { min: 6, max: 128 } };
+    const field: PasswordVerifyField = {
+      type: 'PASSWORD_VERIFY',
+      key: 'user.password',
+      label: 'Password',
+      passwordPolicy: componentPolicy,
+    };
+
+    const result = returnPasswordVerifyCollector(field, 0, rootPolicy);
+
+    expect(result.output.passwordPolicy).toEqual(componentPolicy);
+  });
+
+  it('should have no passwordPolicy when neither field nor root provides one', () => {
+    const field: PasswordVerifyField = {
+      type: 'PASSWORD_VERIFY',
+      key: 'user.password',
+      label: 'Password',
+    };
+
+    const result = returnPasswordVerifyCollector(field, 0, undefined);
+
+    expect(result.output).not.toHaveProperty('passwordPolicy');
+  });
+
   it('should record errors when field is missing properties', () => {
     const invalidField = {} as PasswordVerifyField;
     const result = returnPasswordVerifyCollector(invalidField, 0);

packages/davinci-client/api-report/davinci-client.types.api.md

@@ -38,6 +38,7 @@ import type {
   FidoAuthenticationField,
   FidoRegistrationField,
   MultiSelectField,
+  PasswordPolicy,
   PasswordVerifyField,
   PhoneNumberField,
   ProtectField,
@@ -443,13 +444,16 @@ export function returnPasswordCollector(field: StandardField, idx: number) {
 
 /**
  * @function returnPasswordVerifyCollector - Creates a PasswordVerifyCollector with optional password policy.
+ * Component-level policy takes precedence over root-level (Solution 3: temporary duplication).
  * @param {PasswordVerifyField} field - The PASSWORD_VERIFY field, possibly containing passwordPolicy.
  * @param {number} idx - The index of the field in the form.
+ * @param {PasswordPolicy} [rootPasswordPolicy] - Optional root-level password policy for backward compatibility.
  * @returns {PasswordVerifyCollector} The constructed PasswordVerifyCollector object.
  */
 export function returnPasswordVerifyCollector(
   field: PasswordVerifyField,
   idx: number,
+  rootPasswordPolicy?: PasswordPolicy,
 ): PasswordVerifyCollector {
   let error = '';
   if (!('key' in field)) {
@@ -462,6 +466,9 @@ export function returnPasswordVerifyCollector(
     error = `${error}Type is not found in the field object. `;
   }
 
+  // Component-level policy takes precedence over root-level
+  const passwordPolicy = field.passwordPolicy ?? rootPasswordPolicy;
+
   return {
     category: 'SingleValueCollector',
     error: error || null,
@@ -477,7 +484,7 @@ export function returnPasswordVerifyCollector(
       key: field.key,
       label: field.label,
       type: field.type,
-      ...(field.passwordPolicy && { passwordPolicy: field.passwordPolicy }),
+      ...(passwordPolicy && { passwordPolicy }),
     },
   };
 }

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

@@ -296,6 +296,7 @@ export interface DaVinciNextResponse extends DaVinciBaseResponse {
       fields?: DaVinciField[];
     };
   };
+  passwordPolicy?: PasswordPolicy;
 }
 
 /**

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

@@ -206,6 +206,43 @@ export const obj = {
   region: 'CA',
   themeId: 'activeTheme',
   formId: 'f0cf83ab-f8f4-4f4a-9260-8f7d27061fa7',
+  passwordPolicy: {
+    id: '39cad7af-3c2f-4672-9c3f-c47e5169e582',
+    environment: {
+      id: '02fb4743-189a-4bc7-9d6c-a919edfe6447',
+    },
+    name: 'Standard',
+    description: 'A standard policy that incorporates industry best practices',
+    excludesProfileData: true,
+    notSimilarToCurrent: true,
+    excludesCommonlyUsed: true,
+    maxAgeDays: 182,
+    minAgeDays: 1,
+    maxRepeatedCharacters: 2,
+    minUniqueCharacters: 5,
+    history: {
+      count: 6,
+      retentionDays: 365,
+    },
+    lockout: {
+      failureCount: 5,
+      durationSeconds: 900,
+    },
+    length: {
+      min: 8,
+      max: 255,
+    },
+    minCharacters: {
+      '~!@#$%^&*()-_=+[]{}|;:,.<>/?': 1,
+      '0123456789': 1,
+      ABCDEFGHIJKLMNOPQRSTUVWXYZ: 1,
+      abcdefghijklmnopqrstuvwxyz: 1,
+    },
+    populationCount: 1,
+    createdAt: '2024-01-03T19:50:39.586Z',
+    updatedAt: '2024-01-03T19:50:39.586Z',
+    default: true,
+  },
   isResponseCompatibleWithMobileAndWebSdks: true,
   fieldTypes: [
     'LABEL',

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

@@ -1263,6 +1263,51 @@ describe('PASSWORD_VERIFY with password policy', () => {
     expect(result[0].output).not.toHaveProperty('passwordPolicy');
   });
 
+  it('should fall back to root-level passwordPolicy when field has no policy', () => {
+    const action = {
+      type: 'node/next',
+      payload: {
+        fields: [
+          {
+            type: 'PASSWORD_VERIFY',
+            key: 'user.password',
+            label: 'Password',
+          },
+        ],
+        formData: {},
+        passwordPolicy: mockPasswordPolicy,
+      },
+    };
+    const result = nodeCollectorReducer(undefined, action);
+    expect(result[0].type).toBe('PasswordVerifyCollector');
+    expect((result[0] as PasswordVerifyCollector).output.passwordPolicy).toEqual(
+      mockPasswordPolicy,
+    );
+  });
+
+  it('should prefer component-level policy over root-level', () => {
+    const rootPolicy = { id: 'root-policy', name: 'Root', length: { min: 6, max: 128 } };
+    const action = {
+      type: 'node/next',
+      payload: {
+        fields: [
+          {
+            type: 'PASSWORD_VERIFY',
+            key: 'user.password',
+            label: 'Password',
+            passwordPolicy: mockPasswordPolicy,
+          },
+        ],
+        formData: {},
+        passwordPolicy: rootPolicy,
+      },
+    };
+    const result = nodeCollectorReducer(undefined, action);
+    expect((result[0] as PasswordVerifyCollector).output.passwordPolicy).toEqual(
+      mockPasswordPolicy,
+    );
+  });
+
   it('should still produce PasswordCollector for PASSWORD type (no regression)', () => {
     const action = {
       type: 'node/next',

packages/davinci-client/src/lib/mock-data/mock-form-fields.data.ts

@@ -32,7 +32,7 @@ import {
   returnFidoAuthenticationCollector,
   returnQrCodeCollector,
 } from './collector.utils.js';
-import type { DaVinciField, UnknownField } from './davinci.types.js';
+import type { DaVinciField, PasswordPolicy, UnknownField } from './davinci.types.js';
 import type {
   ActionCollector,
   MultiSelectCollector,
@@ -70,6 +70,7 @@ import type {
 export const nextCollectorValues = createAction<{
   fields: DaVinciField[];
   formData: { value: Record<string, unknown> };
+  passwordPolicy?: PasswordPolicy;
 }>('node/next');
 export const updateCollectorValues = createAction<{
   id: string;
@@ -174,8 +175,8 @@ export const nodeCollectorReducer = createReducer(initialCollectorValues, (build
                 return returnPasswordCollector(field, idx);
               }
               case 'PASSWORD_VERIFY': {
-                // No data to send; policy may be embedded in field
-                return returnPasswordVerifyCollector(field, idx);
+                // No data to send; policy may be embedded in field or at root level
+                return returnPasswordVerifyCollector(field, idx, action.payload.passwordPolicy);
               }
               case 'PHONE_NUMBER': {
                 const prefillData = data as PhoneNumberOutputValue;

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

@@ -185,6 +185,7 @@ export const nodeSlice = createSlice({
         payload: {
           fields: action.payload.data?.form?.components?.fields,
           formData: action.payload.data?.formData,
+          passwordPolicy: action.payload.data?.passwordPolicy,
         },
       });