Bug Fixes - Fortify Schema

✅ Critical Bugs Fixed

We've resolved two major issues affecting array-of-objects validation:

TypeScript Type Inference: Arrays now correctly infer as Array<T> instead of tuple types
Runtime Validation: Array elements are now properly validated against their schema

Array-of-Objects Type Inference

FIXED

❌ Problem

When defining array-of-objects using the syntax videos: [{ ... }], TypeScript was incorrectly inferring it as a tuple type requiring exactly one element, instead of Array<T>.

TypeScript Error:

// Before fix - TypeScript error
const schema = Interface({
  videos: [{
    id: "string",
    title: "string"
  }]
});

const data = {
  videos: [] // ❌ Error: Property '0' is missing in type '[]'
};

🔍 Root Cause

In src/core/schema/mode/interfaces/typescript/TypeInference.ts, the InferFieldType type didn't check for readonly [T] syntax before checking Array<T>. TypeScript treats [{...}] as a tuple type by default.

// Before - Missing tuple check
export type InferFieldType<T> = 
  T extends string
    ? HandleOptional<MapFieldType<T>, IsOptional<T>>
    : T extends Array<infer U>  // ❌ Doesn't match tuple types
      ? Array<InferSchemaType<U>>
      : // ... other types

✅ Solution

Added check for T extends readonly [infer U] before the Array check. This ensures tuple syntax is properly detected and converted to array type.

// After - Tuple check added
export type InferFieldType<T> = 
  T extends string
    ? HandleOptional<MapFieldType<T>, IsOptional<T>>
    : T extends readonly [infer U]  // ✅ Check tuple first
      ? Array<InferSchemaType<U>>
      : T extends Array<infer U>
        ? Array<InferSchemaType<U>>
        : // ... other types

🎉 Result

// After fix - Works correctly
const schema = Interface({
  videos: [{
    id: "string",
    title: "string"
  }]
});

type InferredType = InferType<typeof schema>;
// ✅ { videos: Array<{ id: string; title: string }> }

const data1 = { videos: [] }; // ✅ Valid
const data2 = { videos: [{ id: "1", title: "Video" }] }; // ✅ Valid

Array-of-Objects Runtime Validation

FIXED

❌ Problem

Array-of-objects validation was completely broken. Invalid data was passing through without any validation:

❌ Missing Fields

Required fields were not validated

❌ Wrong Types

Type mismatches were ignored

❌ Not Even Array

Objects passed as arrays

// Before fix - All these incorrectly passed ❌
const schema = Interface({
  videos: [{
    id: "string",
    title: "string",
    duration: "number"
  }]
});

// Missing required fields - should FAIL but PASSED
schema.parse({ videos: [{ id: "1" }] }); // ❌

// Wrong types - should FAIL but PASSED
schema.parse({ videos: [{ id: 123, title: "Test", duration: "wrong" }] }); // ❌

// Not even an array - should FAIL but PASSED
schema.parse({ videos: { id: "1", title: "Test" } }); // ❌

🔍 Root Cause

The precompiled validator was being used for schemas with array-of-objects, but the precompiler doesn't handle them. It was calling String(fieldType) on the array [{ ... }], converting it to "[object Object]", and creating a broken validator that did nothing.

// In SchemaPrecompiler.ts - The bug
private static compileField(fieldName: string, fieldType: any) {
  if (typeof fieldType === "object" && !Array.isArray(fieldType)) {
    // Handle nested objects
  }
  
  // ❌ BUG: Arrays fall through to here
  const fieldTypeStr = String(fieldType); // "[object Object]"
  const validator = FieldPrecompilers.parseAndCompile(fieldTypeStr);
  // Creates broken validator!
}

✅ Solution

Added check in InterfaceSchema.ts to detect array-of-objects fields and skip precompilation, forcing the use of standard validation which correctly handles arrays.

// In InterfaceSchema.ts - The fix
private createPrecompiledValidator(): void {
  const hasConditionalFields = this.compiledFields.some(
    (field) => field.isConditional
  );
  
  // ✅ NEW: Check for array-of-objects fields
  const hasArrayOfObjects = this.compiledFields.some(
    (field) => Array.isArray(field.originalType)
  );
  
  // Skip precompilation if array-of-objects present
  if (!hasConditionalFields && !hasArrayOfObjects && /* other checks */) {
    this.precompiledValidator = SchemaPrecompiler.precompileSchema(...);
  }
  // Otherwise use standard validation (which works correctly)
}

🎉 Result

// After fix - Validation works correctly ✅
const schema = Interface({
  videos: [{
    id: "string",
    title: "string",
    duration: "number"
  }]
});

// Empty array - PASSES (correct, no minimum constraint)
schema.parse({ videos: [] }); // ✅

// Valid data - PASSES
schema.parse({ 
  videos: [{ id: "1", title: "Video", duration: 120 }] 
}); // ✅

// Missing fields - FAILS (correct)
schema.parse({ videos: [{ id: "1" }] }); 
// ❌ Error: Missing required field: title

// Wrong types - FAILS (correct)
schema.parse({ videos: [{ id: 123, title: "Test", duration: "wrong" }] }); 
// ❌ Error: Expected String, but received Number

// Not an array - FAILS (correct)
schema.parse({ videos: { id: "1" } }); 
// ❌ Error: Expected Array, but received Object

✅ Test Results

Test Case	Before	After	Status
Empty array	PASS	PASS	✅ Correct
Valid array elements	PASS	PASS	✅ Correct
Missing required fields	PASS	FAIL	✅ Fixed
Wrong types	PASS	FAIL	✅ Fixed
Not an array	PASS	FAIL	✅ Fixed
TypeScript type inference	Tuple	Array	✅ Fixed

📋 Migration Guide

Good news! These fixes are backward compatible. No changes needed to your existing code.

Empty arrays remain valid by default (use array length constraints if you need minimums)
TypeScript types are now more accurate
Validation is now stricter and catches errors that were previously missed