feat(ArrayType): enhance nested array validation (#82)

* feat(array): enhance nested array validation

- Add support for array index in nested object validation
- Improve getFieldType to handle array paths
- Add comprehensive tests for nested array validation (max 3 levels)
- Add arrayTypeSchemaSpec for better type handling
- Improve error handling in nested structures

* fix: Support nested array validation in ArrayType

- Add isArrayTypeNested flag to handle nested array validation
- Skip array type check for nested array elements
- Update test cases for nested array validation

* Update Schema.ts

Author: simonguo

package-lock.json

@@ -40,8 +40,7 @@
   ],
   "homepage": "https://github.com/rsuite/schema-typed#readme",
   "dependencies": {
-    "get-value": "^3.0.1",
-    "set-value": "^4.1.0"
+    "lodash": "^4.17.21"
   },
   "devDependencies": {
     "@istanbuljs/nyc-config-typescript": "^1.0.2",

package.json

@@ -1,4 +1,4 @@
-import { MixedType } from './MixedType';
+import { MixedType, arrayTypeSchemaSpec } from './MixedType';
 import { PlainObject, CheckResult, ErrorMessageType } from './types';
 import { ArrayTypeLocale } from './locales';
 
@@ -8,10 +8,19 @@ export class ArrayType<DataType = any, E = ErrorMessageType> extends MixedType<
   E,
   ArrayTypeLocale
 > {
+  [arrayTypeSchemaSpec]: MixedType<any, DataType, E>;
+  private isArrayTypeNested = false;
+
   constructor(errorMessage?: E | string) {
     super('array');
     super.pushRule({
-      onValid: v => Array.isArray(v),
+      onValid: v => {
+        // Skip array type check for nested array elements
+        if (this.isArrayTypeNested) {
+          return true;
+        }
+        return Array.isArray(v);
+      },
       errorMessage: errorMessage || this.locale.type
     });
   }
@@ -67,8 +76,28 @@ export class ArrayType<DataType = any, E = ErrorMessageType> extends MixedType<
   }
 
   of(type: MixedType<any, DataType, E>) {
+    this[arrayTypeSchemaSpec] = type;
+    
+    // Mark inner ArrayType as nested when dealing with nested arrays
+    if (type instanceof ArrayType) {
+      type.isArrayTypeNested = true;
+    }
+
     super.pushRule({
       onValid: (items, data, fieldName) => {
+        // For non-array values in nested arrays, pass directly to inner type validation
+        if (!Array.isArray(items) && this.isArrayTypeNested) {
+          return type.check(items, data, fieldName);
+        }
+
+        // For non-array values in non-nested arrays, return array type error
+        if (!Array.isArray(items)) {
+          return {
+            hasError: true,
+            errorMessage: this.locale.type
+          };
+        }
+
         const checkResults = items.map((value, index) => {
           const name = Array.isArray(fieldName)
             ? [...fieldName, `[${index}]`]

src/ArrayType.ts

@@ -26,14 +26,38 @@ type ProxyOptions = {
 };
 
 export const schemaSpecKey = 'objectTypeSchemaSpec';
+export const arrayTypeSchemaSpec = 'arrayTypeSchemaSpec';
 
 /**
  * Get the field type from the schema object
  */
 export function getFieldType(schemaSpec: any, fieldName: string, nestedObject?: boolean) {
   if (nestedObject) {
-    const namePath = fieldName.split('.').join(`.${schemaSpecKey}.`);
-    return get(schemaSpec, namePath);
+    const namePath = fieldName.split('.');
+    const currentField = namePath[0];
+    const arrayMatch = currentField.match(/(\w+)\[(\d+)\]/);
+
+    if (arrayMatch) {
+      const [, arrayField] = arrayMatch;
+      const type = schemaSpec[arrayField];
+
+      if (type?.[arrayTypeSchemaSpec]) {
+        // If there are remaining paths and the type is ObjectType (has schemaSpecKey)
+        if (namePath.length > 1 && type[arrayTypeSchemaSpec][schemaSpecKey]) {
+          return getFieldType(
+            type[arrayTypeSchemaSpec][schemaSpecKey],
+            namePath.slice(1).join('.'),
+            true
+          );
+        }
+        // Otherwise return the array element type directly
+        return type[arrayTypeSchemaSpec];
+      }
+      return type;
+    }
+
+    const joinedPath = namePath.join(`.${schemaSpecKey}.`);
+    return get(schemaSpec, joinedPath);
   }
   return schemaSpec?.[fieldName];
 }

src/MixedType.ts

@@ -11,6 +11,7 @@ interface CheckOptions {
 
 export class Schema<DataType = any, ErrorMsgType = string> {
   readonly $spec: SchemaDeclaration<DataType, ErrorMsgType>;
+  
   private data: PlainObject;
   private checkResult: SchemaCheckResult<DataType, ErrorMsgType> = {};
 
@@ -37,7 +38,7 @@ export class Schema<DataType = any, ErrorMsgType = string> {
       return;
     }
 
-    this.checkResult[fieldName as string] = checkResult;
+    this.checkResult[fieldName] = checkResult;
   }
 
   private setSchemaOptionsForAllType(data: PlainObject) {

src/Schema.ts

@@ -1,5 +1,5 @@
-export { default as get } from 'get-value';
-export { default as set } from 'set-value';
+export { default as get } from 'lodash/get';
+export { default as set } from 'lodash/set';
 export { default as basicEmptyCheck } from './basicEmptyCheck';
 export { default as checkRequired } from './checkRequired';
 export { default as createValidator } from './createValidator';