feat: added deep nested check for $validate type output

packages/core/src/types/core/useRegle.types.ts

@@ -3,14 +3,13 @@ import type { MaybeRef } from 'vue';
 import type {
   CustomRulesDeclarationTree,
   RegleCollectionRuleDecl,
-  RegleCollectionRuleDefinition,
   RegleFormPropertyType,
   ReglePartialRuleTree,
   RegleRoot,
   RegleRuleDecl,
   RegleRuleDefinition,
 } from '../rules';
-import type { ExtendOnlyRealRecord, ExtractFromGetter, Maybe, Prettify } from '../utils';
+import type { ArrayElement, ExtendOnlyRealRecord, ExtractFromGetter, Maybe, Prettify } from '../utils';
 import type { RegleShortcutDefinition, RegleValidationGroupEntry } from './options.types';
 
 export interface Regle<
@@ -50,21 +49,24 @@ export type DeepReactiveState<T extends Record<string, any>> = {
 
 export type DeepSafeFormState<
   TState extends Record<string, any>,
-  TRules extends ReglePartialRuleTree<TState, CustomRulesDeclarationTree>,
+  TRules extends ReglePartialRuleTree<TState, CustomRulesDeclarationTree> | undefined,
 > = [unknown] extends [TState]
   ? {}
-  : Prettify<
-      {
-        [K in keyof TState as IsPropertyOutputRequired<TState[K], TRules[K]> extends false ? K : never]?: SafeProperty<
-          TState[K],
-          TRules[K]
-        >;
-      } & {
-        [K in keyof TState as IsPropertyOutputRequired<TState[K], TRules[K]> extends false ? never : K]-?: NonNullable<
-          SafeProperty<TState[K], TRules[K]>
-        >;
-      }
-    >;
+  : TRules extends undefined
+    ? TState
+    : TRules extends ReglePartialRuleTree<TState, CustomRulesDeclarationTree>
+      ? Prettify<
+          {
+            [K in keyof TState as IsPropertyOutputRequired<TState[K], TRules[K]> extends false
+              ? K
+              : never]?: SafeProperty<TState[K], TRules[K]>;
+          } & {
+            [K in keyof TState as IsPropertyOutputRequired<TState[K], TRules[K]> extends false
+              ? never
+              : K]-?: NonNullable<SafeProperty<TState[K], TRules[K]>>;
+          }
+        >
+      : TState;
 
 type FieldHaveRequiredRule<TRule extends RegleRuleDecl> = unknown extends TRule['required']
   ? false
@@ -76,25 +78,33 @@ type FieldHaveRequiredRule<TRule extends RegleRuleDecl> = unknown extends TRule[
         : false
       : false;
 
-type ObjectHaveAtLeastOneRequiredField<TState, TRule extends ReglePartialRuleTree<any, any>> =
+type ObjectHaveAtLeastOneRequiredField<
+  TState extends Record<string, any>,
+  TRule extends ReglePartialRuleTree<TState, any>,
+> =
   TState extends Maybe<TState>
     ? {
-        [K in keyof TRule]: TRule[K] extends RegleRuleDecl ? FieldHaveRequiredRule<TRule[K]> : false;
-      }[keyof TRule]
+        [K in keyof NonNullable<TState>]-?: IsPropertyOutputRequired<NonNullable<TState>[K], TRule[K]>;
+      }[keyof TState] extends false
+      ? false
+      : true
     : true;
 
-type ArrayHaveAtLeastOneRequiredField<TState, TRule extends RegleCollectionRuleDefinition<any, any>> =
+type ArrayHaveAtLeastOneRequiredField<TState extends Maybe<any[]>, TRule extends RegleCollectionRuleDecl<TState>> =
   TState extends Maybe<TState>
-    ? {
-        [K in keyof ExtractFromGetter<TRule['$each']>]: ExtractFromGetter<TRule['$each']>[K] extends RegleRuleDecl
-          ? FieldHaveRequiredRule<ExtractFromGetter<TRule['$each']>[K]>
-          : false;
-      }[keyof ExtractFromGetter<TRule['$each']>]
+    ?
+        | FieldHaveRequiredRule<Omit<TRule, '$each'> extends RegleRuleDecl ? Omit<TRule, '$each'> : {}>
+        | ObjectHaveAtLeastOneRequiredField<
+            ArrayElement<NonNullable<TState>>,
+            ExtractFromGetter<TRule['$each']> extends undefined ? {} : NonNullable<ExtractFromGetter<TRule['$each']>>
+          > extends false
+      ? false
+      : true
     : true;
 
 export type SafeProperty<TState, TRule extends RegleFormPropertyType<any, any> | undefined> = [unknown] extends [TState]
   ? unknown
-  : TRule extends RegleCollectionRuleDefinition<any, any>
+  : TRule extends RegleCollectionRuleDecl<any, any>
     ? TState extends Array<infer U extends Record<string, any>>
       ? DeepSafeFormState<U, ExtractFromGetter<TRule['$each']>>[]
       : TState
@@ -112,21 +122,24 @@ export type IsPropertyOutputRequired<TState, TRule extends RegleFormPropertyType
   unknown,
 ] extends [TState]
   ? unknown
-  : TRule extends RegleCollectionRuleDefinition<any, any>
-    ? TState extends Array<any>
-      ? ArrayHaveAtLeastOneRequiredField<TState, TRule> extends true
-        ? true
-        : false
+  : NonNullable<TState> extends Array<any>
+    ? TRule extends RegleCollectionRuleDecl<any, any>
+      ? ArrayHaveAtLeastOneRequiredField<NonNullable<TState>, TRule> extends false
+        ? false
+        : true
       : false
     : TRule extends ReglePartialRuleTree<any, any>
       ? ExtendOnlyRealRecord<TState> extends true
-        ? ObjectHaveAtLeastOneRequiredField<TState, TRule> extends true
-          ? true
-          : false
+        ? ObjectHaveAtLeastOneRequiredField<
+            NonNullable<TState> extends Record<string, any> ? NonNullable<TState> : {},
+            TRule
+          > extends false
+          ? false
+          : true
         : TRule extends RegleRuleDecl<any, any>
-          ? FieldHaveRequiredRule<TRule> extends true
-            ? true
-            : false
+          ? FieldHaveRequiredRule<TRule> extends false
+            ? false
+            : true
           : false
       : false;
 

packages/core/src/types/rules/rule.declaration.types.ts

@@ -108,7 +108,7 @@ export type RegleRuleDecl<
  * @internal
  * @reference {@link RegleRuleDecl}
  */
-export type $InternalRegleRuleDecl = Record<string, FormRuleDeclaration<any, any>>;
+export type $InternalRegleRuleDecl = FieldRegleBehaviourOptions & Record<string, FormRuleDeclaration<any, any>>;
 
 /**
  * @public

packages/nuxt/test/fixtures/pages/index.vue

@@ -1,11 +1,41 @@
 <template>
-  <div>{{ r$.$fields.name.$value }}</div>
+  <div>{{ r$.$fields.fullName.$value }}</div>
 </template>
 
 <script setup lang="ts">
-import { required } from '@regle/rules';
+import { minLength, required, email, dateBefore, and, checked } from '@regle/rules';
 
-const { r$ } = useRegle({ name: 'hello' }, { name: { required: withMessage(required, 'foo') } });
+interface Form {
+  fullName?: string;
+  email?: string;
+  eventDate?: Date;
+  eventType?: string;
+  details?: string;
+  acceptTC?: boolean;
+}
+
+const { r$ } = useRegle({ fullName: 'Hello' } as Form, {
+  fullName: { required, minLength: minLength(6) },
+  email: { required, email },
+  eventDate: {
+    required,
+    dateBefore: withTooltip(dateBefore(new Date()), ({ $dirty }) => {
+      if (!$dirty) return 'You must put a date before today';
+      return '';
+    }),
+  },
+  eventType: { required },
+  details: {
+    minLength: withMessage(
+      minLength(100),
+      ({ $value, $params: [min] }) => `Your details are too short: ${$value?.length}/${min}`
+    ),
+  },
+  acceptTC: {
+    $autoDirty: false,
+    required: withMessage(and(required, checked), 'You must accept the terms and conditions'),
+  },
+});
 </script>
 
 <style lang="scss" scoped></style>

packages/nuxt/test/nuxt.spec.ts

@@ -10,6 +10,6 @@ describe('ssr', async () => {
 
   it('renders the index page', async () => {
     const html = await $fetch('/');
-    expect(html).toContain('<div>hello</div>');
+    expect(html).toContain('<div>Hello</div>');
   });
 });

tests/unit/createRule/createRule.spec.ts

@@ -1,4 +1,4 @@
-import { createRule, type RegleRuleDefinition } from '@regle/core';
+import { createRule, type RegleRuleDefinition, type RegleRuleWithParamsDefinition } from '@regle/core';
 
 describe('createRule', () => {
   it('should error when creating a rule without a function', () => {
@@ -69,7 +69,7 @@ describe('createRule', () => {
       message: '',
     });
 
-    expect(await rule.exec('fooo')).toBe(false);
+    expect(rule.exec('fooo')).toBe(false);
   });
 
   it('should recognize mutliple parameters with default', async () => {
@@ -83,11 +83,15 @@ describe('createRule', () => {
     expect(rule().exec('fooo')).toBe(true);
     expect(rule(true).exec('fooo')).toBe(true);
     expect(rule(true, true).exec('fooo')).toBe(true);
+
+    expectTypeOf(rule).toEqualTypeOf<
+      RegleRuleWithParamsDefinition<unknown, [param?: any, param2?: any], false, true>
+    >();
   });
 
   it('should recognize mutliple parameters with spread', async () => {
     const rule = createRule({
-      validator(value, ...params: any[]) {
+      validator(value, ...params: boolean[]) {
         return true;
       },
       message: '',
@@ -96,5 +100,7 @@ describe('createRule', () => {
     expect(rule().exec('fooo')).toBe(true);
     expect(rule(true).exec('fooo')).toBe(true);
     expect(rule(true, true).exec('fooo')).toBe(true);
+
+    expectTypeOf(rule).toEqualTypeOf<RegleRuleWithParamsDefinition<unknown, boolean[], false, true>>();
   });
 });

tests/unit/useRegle/validate/$validate.spec.ts

@@ -11,6 +11,7 @@ function simpleNestedStateWithMixedValidation() {
       lastName?: string;
     };
     contacts?: [{ name: string }];
+    collection?: [{ name: string }];
   }
 
   return useRegle({} as Form, {
@@ -23,6 +24,9 @@ function simpleNestedStateWithMixedValidation() {
         name: { required },
       },
     },
+    collection: {
+      required,
+    },
   });
 }
 
@@ -44,6 +48,9 @@ describe('$validate', () => {
         contacts: {
           name: string;
         }[];
+        collection: {
+          name: string;
+        }[];
       }>();
     } else {
       expectTypeOf(data).toEqualTypeOf<{
@@ -56,6 +63,9 @@ describe('$validate', () => {
         contacts?: {
           name?: Maybe<string>;
         }[];
+        collection?: {
+          name?: Maybe<string>;
+        }[];
       }>();
     }
   });