reliant-type 1.0.0

package/src/core/schema/extensions/components/ConditionalValidation/index.ts

@@ -0,0 +1,104 @@
+/**
+ * Conditional Validation - dependent field validation
+ *
+ * This module provides powerful conditional validation where fields can depend
+ * on other fields' values, making complex business logic validation simple.
+ */
+
+import { SchemaInterface } from "../../../mode/interfaces/Interface";
+import { ConditionalBuilder } from "./ConditionalBuilder";
+import { MultiConditionalBuilder } from "./MultiConditionalBuilder";
+import { CustomValidator } from "./MultiConditionalThen";
+
+/**
+ * Conditional validation utilities
+ */
+export const When = {
+  /**
+   * Create conditional validation based on another field's value
+   *
+   * @example
+   * ```typescript
+   * const UserSchema = Interface({
+   *   accountType: Make.union("free", "premium", "enterprise"),
+   *   maxProjects: When.field("accountType").is("free").then("int(1,3)")
+   *                   .is("premium").then("int(1,50)")
+   *                   .is("enterprise").then("int(1,)")
+   *                   .default("int(1,1)"),
+   *
+   *   paymentMethod: When.field("accountType").isNot("free").then("string").else("string?"),
+   *   billingAddress: When.field("paymentMethod").exists().then({
+   *     street: "string",
+   *     city: "string",
+   *     country: "string(2,2)"
+   *   }).else("any?")
+   * });
+   * ```
+   */
+  field(fieldName: string): ConditionalBuilder {
+    return new ConditionalBuilder(fieldName);
+  },
+
+  /**
+   * Create validation that depends on multiple fields
+   *
+   * @example
+   * ```typescript
+   * const OrderSchema = Interface({
+   *   orderType: Make.union("pickup", "delivery"),
+   *   address: "string?",
+   *   deliveryFee: "number?",
+   *
+   *   // Complex conditional validation
+   *   ...When.fields(["orderType", "address"]).match({
+   *     orderType: "delivery",
+   *     address: (val) => val && val.length > 0
+   *   }).then({
+   *     deliveryFee: "number(0,)"  // Required for delivery with address
+   *   }).else({
+   *     deliveryFee: "number?"     // Optional otherwise
+   *   })
+   * });
+   * ```
+   */
+  fields(fieldNames: string[]): MultiConditionalBuilder {
+    return new MultiConditionalBuilder(fieldNames);
+  },
+
+  /**
+   * Create custom validation logic
+   *
+   * @example
+   * ```typescript
+   * const EventSchema = Interface({
+   *   startDate: "date",
+   *   endDate: "date",
+   *
+   *   // Custom validation: endDate must be after startDate
+   *   ...When.custom((data) => {
+   *     if (data.endDate <= data.startDate) {
+   *       return { error: "End date must be after start date" };
+   *     }
+   *     return { valid: true };
+   *   })
+   * });
+   * ```
+   */
+  custom(
+    validator: (data: any) => { valid: true } | { error: string }
+  ): CustomValidator {
+    return new CustomValidator(validator);
+  },
+
+  // Note: Clean syntax like "when:role=admin:string:string?" is automatically
+  // supported in Interface schemas without needing to import When utilities.
+  // The syntax is parsed internally by the schema validation engine.
+};
+
+/**
+ * Export all utilities
+ */
+export { ConditionalBuilder, MultiConditionalBuilder, CustomValidator };
+export { ConditionalElse } from "./ConditionalElse";
+export { ExtendBuilder, Extend } from "./Extend";
+export default When;

package/src/core/schema/extensions/components/RealtimeValidation/FormValidator.ts

@@ -0,0 +1,88 @@
+import { LiveValidator } from "./LiveValidator";
+
+/**
+ * Form validator with DOM integration
+ */
+export class FormValidator extends LiveValidator {
+    private boundFields: Record<string, HTMLElement> = {};
+    private autoValidationEnabled = false;
+    private submitListeners: Array<(isValid: boolean, data: any, errors: Record<string, string[]>) => void> = [];
+
+    /**
+     * Bind a form field for automatic validation (Node.js compatible)
+     */
+    bindField(fieldName: string, element: any): void {
+        this.boundFields[fieldName] = element;
+
+        if (this.autoValidationEnabled) {
+            this.setupFieldListeners(fieldName, element);
+        }
+    }
+
+    /**
+     * Enable automatic validation on input changes (Node.js compatible)
+     */
+    enableAutoValidation(): void {
+        this.autoValidationEnabled = true;
+
+        Object.entries(this.boundFields).forEach(([fieldName, element]) => {
+            this.setupFieldListeners(fieldName, element);
+        });
+    }
+
+    /**
+     * Listen for form submission
+     */
+    onSubmit(listener: (isValid: boolean, data: any, errors: Record<string, string[]>) => void): void {
+        this.submitListeners.push(listener);
+    }
+
+    /**
+     * Trigger form validation (typically on submit)
+     */
+    submit(): void {
+        const result = this.validateAll();
+        this.submitListeners.forEach(listener =>
+            listener(result.isValid, result.data, result.errors)
+        );
+    } 
+
+    private setupFieldListeners(fieldName: string, element: any): void {
+        // Check if we're in a browser environment
+        if (typeof globalThis !== 'undefined' && (globalThis as any).window && element && typeof element.addEventListener === 'function') {
+            // Browser environment - set up real DOM event listeners
+            const handleInput = (event: any) => {
+                const target = event.target;
+                const value = target.value !== undefined ? target.value : target.textContent;
+                this.validateField(fieldName, value);
+            };
+
+            const handleChange = (event: any) => {
+                const target = event.target;
+                const value = target.value !== undefined ? target.value : target.textContent;
+                this.validateField(fieldName, value);
+            };
+
+            // Add event listeners for real-time validation
+            element.addEventListener('input', handleInput);
+            element.addEventListener('change', handleChange);
+            element.addEventListener('blur', handleChange);
+
+            // Store cleanup function for later removal
+            if (!element._fortifyCleanup) {
+                element._fortifyCleanup = () => {
+                    element.removeEventListener('input', handleInput);
+                    element.removeEventListener('change', handleChange);
+                    element.removeEventListener('blur', handleChange);
+                };
+            }
+        } else {
+            // Node.js environment - provide programmatic interface
+            if (!element._fortifyValidate) {
+                element._fortifyValidate = (value: any) => {
+                    return this.validateField(fieldName, value);
+                };
+            }
+        }
+    }
+}

package/src/core/schema/extensions/components/RealtimeValidation/LiveValidator.ts

@@ -0,0 +1,171 @@
+import {
+  FieldValidationResult,
+  ValidationResult,
+} from "../../../../types/extension.type";
+import { SchemaInterface } from "../../../../types/SchemaValidator.type";
+import { ValidationEngine } from "../../mods";
+
+/**
+ * Live validator for real-time validation
+ */
+export class LiveValidator {
+  private currentData: any = {};
+  private currentErrors: Record<string, string[]> = {};
+  private listeners: Array<(result: ValidationResult) => void> = [];
+  private fieldListeners: Record<
+    string,
+    Array<(result: FieldValidationResult) => void>
+  > = {};
+
+  constructor(private schema: SchemaInterface) {}
+
+  /**
+   * Validate a single field in real-time
+   */
+  validateField(fieldName: string, value: any): FieldValidationResult {
+    this.currentData[fieldName] = value;
+
+    // Check if schema is an Interface schema (has definition property)
+    let fieldSchema;
+    if (
+      (this.schema as any).definition &&
+      (this.schema as any).definition[fieldName]
+    ) {
+      fieldSchema = (this.schema as any).definition[fieldName];
+    } else {
+      fieldSchema = (this.schema as any)[fieldName];
+    }
+
+    // console.log("field: ", fieldSchema);
+    // console.log("fieldName: ", fieldName);
+
+    const validationResult = ValidationEngine.validateField(fieldSchema, value);
+
+    this.currentErrors[fieldName] = validationResult.errors;
+
+    const result: FieldValidationResult = {
+      field: fieldName,
+      value,
+      isValid: validationResult.isValid,
+      errors: validationResult.errors,
+    };
+
+    // Notify field listeners
+    if (this.fieldListeners[fieldName]) {
+      this.fieldListeners[fieldName].forEach((listener) => listener(result));
+    }
+
+    // Notify global listeners
+    this.notifyListeners();
+
+    // Validate all
+    this.validateAll();
+
+    return result;
+  }
+
+  /**
+   * Validate all current data
+   */
+  validateAll(): ValidationResult {
+    // Check if schema is an Interface schema (has safeParse method)
+    if ((this.schema as any).safeParse) {
+      // Use Interface schema's built-in validation
+      const validationResult = (this.schema as any).safeParse(this.currentData);
+
+      const errors: Record<string, string[]> = {};
+      if (!validationResult.success && validationResult.errors) {
+        // Convert Interface errors to LiveValidator format
+        Object.entries(validationResult.errors).forEach(([key, value]) => {
+          errors[key] = Array.isArray(value) ? value : [String(value)];
+        });
+      }
+
+      this.currentErrors = errors;
+
+      const result: ValidationResult = {
+        isValid: validationResult.success,
+        data: this.currentData,
+        errors: this.currentErrors,
+        timestamp: new Date(),
+      };
+
+      // Notify listeners after creating the result
+      this.listeners.forEach((listener) => listener(result));
+
+      return result;
+    } else {
+      // Fallback to ValidationEngine for other schema types
+      const validationResult = ValidationEngine.validateObject(
+        this.schema,
+        this.currentData
+      );
+
+      // Update current errors with validation results
+      this.currentErrors = validationResult.errors;
+
+      const result: ValidationResult = {
+        isValid: validationResult.isValid,
+        data: this.currentData,
+        errors: this.currentErrors,
+        timestamp: new Date(),
+      };
+
+      // Notify listeners after creating the result
+      this.listeners.forEach((listener) => listener(result));
+
+      return result;
+    }
+  }
+
+  /**
+   * Listen for validation changes
+   */
+  onValidation(listener: (result: ValidationResult) => void): void {
+    this.listeners.push(listener);
+  }
+
+  /**
+   * Listen for specific field validation
+   */
+  onFieldValidation(
+    fieldName: string,
+    listener: (result: FieldValidationResult) => void
+  ): void {
+    if (!this.fieldListeners[fieldName]) {
+      this.fieldListeners[fieldName] = [];
+    }
+    this.fieldListeners[fieldName].push(listener);
+  }
+
+  /**
+   * Get current validation state
+   */
+  get isValid(): boolean {
+    return Object.values(this.currentErrors).every(
+      (errors) => errors.length === 0
+    );
+  }
+
+  get errors(): Record<string, string[]> {
+    return { ...this.currentErrors };
+  }
+
+  get data(): any {
+    return { ...this.currentData };
+  }
+
+  private notifyListeners(): void {
+    // Create validation result without calling validateAll to avoid recursion
+    const result: ValidationResult = {
+      isValid: Object.values(this.currentErrors).every(
+        (errors) => errors.length === 0
+      ),
+      data: this.currentData,
+      errors: this.currentErrors,
+      timestamp: new Date(),
+    };
+
+    this.listeners.forEach((listener) => listener(result));
+  }
+}