reliant-type 1.0.0

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

@@ -0,0 +1,397 @@
+import { ValidationStats } from "../../../../types/extension.type";
+import { SchemaInterface } from "../../../../types/SchemaValidator.type";
+import { ValidationEngine } from "../../mods";
+
+/**
+ * Enhanced Stream Validator with full EventEmitter-like interface
+ * Supports all standard stream methods (.on, .emit, .pipe, etc.)
+ * Synchronized with InterfaceSchema modules
+ */
+export class StreamValidator {
+  private validListeners: Array<(data: any) => void> = [];
+  private invalidListeners: Array<
+    (data: any, errors: Record<string, string[]>) => void
+  > = [];
+  private statsListeners: Array<(stats: ValidationStats) => void> = [];
+
+  // Enhanced event system
+  private eventListeners: Map<string, Array<(...args: any[]) => void>> =
+    new Map();
+  private onceListeners: Map<string, Array<(...args: any[]) => void>> =
+    new Map();
+
+  // Stream control
+  private isPaused: boolean = false;
+  private isDestroyed: boolean = false;
+  private dataQueue: any[] = [];
+
+  // Data transformation pipeline
+  private transformers: Array<(data: any) => any> = [];
+  private filters: Array<(data: any) => boolean> = [];
+  private mappers: Array<(data: any) => any> = [];
+
+  private stats: ValidationStats = {
+    totalValidated: 0,
+    validCount: 0,
+    invalidCount: 0,
+    errorRate: 0,
+    startTime: new Date(),
+  };
+
+  constructor(private schema: SchemaInterface) {}
+
+  // =================================================================
+  // CORE EVENT EMITTER METHODS
+  // =================================================================
+
+  /**
+   * Generic event listener (EventEmitter-like interface)
+   */
+  on(event: string, listener: (...args: any[]) => void): this {
+    if (this.isDestroyed) throw new Error("StreamValidator is destroyed");
+
+    if (!this.eventListeners.has(event)) {
+      this.eventListeners.set(event, []);
+    }
+    this.eventListeners.get(event)!.push(listener);
+    return this;
+  }
+
+  /**
+   * One-time event listener
+   */
+  once(event: string, listener: (...args: any[]) => void): this {
+    if (this.isDestroyed) throw new Error("StreamValidator is destroyed");
+
+    if (!this.onceListeners.has(event)) {
+      this.onceListeners.set(event, []);
+    }
+    this.onceListeners.get(event)!.push(listener);
+    return this;
+  }
+
+  /**
+   * Remove event listener
+   */
+  off(event: string, listener?: (...args: any[]) => void): this {
+    if (listener) {
+      // Remove specific listener
+      const listeners = this.eventListeners.get(event);
+      if (listeners) {
+        const index = listeners.indexOf(listener);
+        if (index > -1) listeners.splice(index, 1);
+      }
+
+      const onceListeners = this.onceListeners.get(event);
+      if (onceListeners) {
+        const index = onceListeners.indexOf(listener);
+        if (index > -1) onceListeners.splice(index, 1);
+      }
+    } else {
+      // Remove all listeners for event
+      this.eventListeners.delete(event);
+      this.onceListeners.delete(event);
+    }
+    return this;
+  }
+
+  /**
+   * Emit event to all listeners
+   */
+  emit(event: string, ...args: any[]): boolean {
+    if (this.isDestroyed) return false;
+
+    let hasListeners = false;
+
+    // Regular listeners
+    const listeners = this.eventListeners.get(event);
+    if (listeners && listeners.length > 0) {
+      hasListeners = true;
+      listeners.forEach((listener) => {
+        try {
+          listener(...args);
+        } catch (error) {
+          this.emit("error", error);
+        }
+      });
+    }
+
+    // Once listeners
+    const onceListeners = this.onceListeners.get(event);
+    if (onceListeners && onceListeners.length > 0) {
+      hasListeners = true;
+      onceListeners.forEach((listener) => {
+        try {
+          listener(...args);
+        } catch (error) {
+          this.emit("error", error);
+        }
+      });
+      this.onceListeners.delete(event); // Clear once listeners
+    }
+
+    return hasListeners;
+  }
+
+  // =================================================================
+  // ENHANCED VALIDATION WITH STREAM CONTROL
+  // =================================================================
+
+  /**
+   * Enhanced validate method with stream control and InterfaceSchema sync
+   */
+  validate(data: any): void {
+    if (this.isDestroyed) {
+      this.emit("error", new Error("Cannot validate on destroyed stream"));
+      return;
+    }
+
+    if (this.isPaused) {
+      this.dataQueue.push(data);
+      this.emit("queued", data);
+      return;
+    }
+
+    this._processData(data);
+  }
+
+  private _processData(data: any): void {
+    this.stats.totalValidated++;
+    this.emit("data", data);
+
+    try {
+      // Apply data transformation pipeline
+      let processedData = this._applyTransformations(data);
+
+      // Apply filters
+      if (!this._passesFilters(processedData)) {
+        this.emit("filtered", processedData);
+        return;
+      }
+
+      // FIXED: Use InterfaceSchema.safeParse for proper validation sync
+      let validationResult;
+      if (typeof this.schema.safeParse === "function") {
+        // Use InterfaceSchema validation
+        const result = this.schema.safeParse(processedData);
+        validationResult = {
+          isValid: result.success,
+          errors: result.success ? {} : this._formatErrors(result.errors),
+        };
+      } else {
+        // Fallback to ValidationEngine
+        validationResult = ValidationEngine.validateObject(
+          this.schema,
+          processedData
+        );
+      }
+
+      if (validationResult.isValid) {
+        this.stats.validCount++;
+        this.validListeners.forEach((listener) => listener(processedData));
+        this.emit("valid", processedData);
+      } else {
+        this.stats.invalidCount++;
+        this.invalidListeners.forEach((listener) =>
+          listener(processedData, validationResult.errors)
+        );
+        this.emit("invalid", processedData, validationResult.errors);
+      }
+
+      this.updateStats();
+      this.emit("validated", processedData, validationResult);
+    } catch (error) {
+      this.emit("error", error);
+    }
+  }
+
+  private _formatErrors(errors: any[]): Record<string, string[]> {
+    const formatted: Record<string, string[]> = {};
+    errors.forEach((error) => {
+      const field = error.path || "unknown";
+      if (!formatted[field]) formatted[field] = [];
+      formatted[field].push(error.message || error.toString());
+    });
+    return formatted;
+  }
+
+  private _applyTransformations(data: any): any {
+    let result = data;
+    for (const transformer of this.transformers) {
+      result = transformer(result);
+    }
+    for (const mapper of this.mappers) {
+      result = mapper(result);
+    }
+    return result;
+  }
+
+  private _passesFilters(data: any): boolean {
+    return this.filters.every((filter) => filter(data));
+  }
+
+  /**
+   * Listen for valid data
+   */
+  onValid(listener: (data: any) => void): void {
+    this.validListeners.push(listener);
+  }
+
+  /**
+   * Listen for invalid data
+   */
+  onInvalid(
+    listener: (data: any, errors: Record<string, string[]>) => void
+  ): void {
+    this.invalidListeners.push(listener);
+  }
+
+  /**
+   * Listen for validation statistics
+   */
+  onStats(listener: (stats: ValidationStats) => void): void {
+    this.statsListeners.push(listener);
+  }
+
+  /**
+   * Get current validation statistics
+   */
+  getStats(): ValidationStats {
+    return { ...this.stats };
+  }
+
+  private updateStats(): void {
+    this.stats.errorRate =
+      this.stats.totalValidated > 0
+        ? this.stats.invalidCount / this.stats.totalValidated
+        : 0;
+
+    this.statsListeners.forEach((listener) => listener(this.stats));
+  }
+
+  // =================================================================
+  // DATA TRANSFORMATION METHODS
+  // =================================================================
+
+  /**
+   * Add data transformer to pipeline
+   */
+  transform(transformer: (data: any) => any): this {
+    if (this.isDestroyed) throw new Error("StreamValidator is destroyed");
+    this.transformers.push(transformer);
+    return this;
+  }
+
+  /**
+   * Add data filter to pipeline
+   */
+  filter(predicate: (data: any) => boolean): this {
+    if (this.isDestroyed) throw new Error("StreamValidator is destroyed");
+    this.filters.push(predicate);
+    return this;
+  }
+
+  /**
+   * Add data mapper to pipeline
+   */
+  map(mapper: (data: any) => any): this {
+    if (this.isDestroyed) throw new Error("StreamValidator is destroyed");
+    this.mappers.push(mapper);
+    return this;
+  }
+
+  /**
+   * Pipe data to another stream validator
+   */
+  pipe(destination: StreamValidator) {
+    if (this.isDestroyed) throw new Error("StreamValidator is destroyed");
+
+    this.on("valid", (data) => {
+      destination.validate(data);
+    });
+
+    this.on("error", (error) => {
+      destination.emit("error", error);
+    });
+
+    return destination; 
+  } 
+
+  // =================================================================
+  // STREAM CONTROL METHODS
+  // =================================================================
+
+  /**
+   * Pause the stream (queue incoming data)
+   */
+  pause(): this {
+    this.isPaused = true;
+    this.emit("pause");
+    return this;
+  }
+
+  /**
+   * Resume the stream (process queued data)
+   */
+  resume(): this {
+    if (this.isDestroyed) throw new Error("StreamValidator is destroyed");
+
+    this.isPaused = false;
+    this.emit("resume");
+
+    // Process queued data
+    const queuedData = [...this.dataQueue];
+    this.dataQueue = [];
+
+    queuedData.forEach((data) => this._processData(data));
+
+    return this;
+  }
+
+  /**
+   * Destroy the stream (cleanup and prevent further use)
+   */
+  destroy(): this {
+    if (this.isDestroyed) return this;
+
+    this.isDestroyed = true;
+    this.isPaused = false;
+
+    // Clear all data
+    this.dataQueue = [];
+    this.transformers = [];
+    this.filters = [];
+    this.mappers = [];
+
+    // Clear all listeners
+    this.validListeners = [];
+    this.invalidListeners = [];
+    this.statsListeners = [];
+    this.eventListeners.clear();
+    this.onceListeners.clear();
+
+    this.emit("destroy");
+    return this;
+  }
+
+  /**
+   * Check if stream is destroyed
+   */
+  get destroyed(): boolean {
+    return this.isDestroyed;
+  }
+
+  /**
+   * Check if stream is paused
+   */
+  get paused(): boolean {
+    return this.isPaused;
+  }
+
+  /**
+   * Get queue length
+   */
+  get queueLength(): number {
+    return this.dataQueue.length;
+  }
+}

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

@@ -0,0 +1,114 @@
+/**
+ * Real-time Validation - live validation system
+ *
+ * This module provides real-time validation with reactive updates,
+ * perfect for forms and live data validation.
+ *
+ * Uses modular validation engine for consistent validation logic.
+ */
+
+import { SchemaInterface } from "../../../mode/interfaces/Interface";
+import {
+  ValidationEngine,
+  ValidationResult as EngineValidationResult,
+} from "../../mods/validation-engine";
+import { FormValidator } from "./FormValidator";
+import { LiveValidator } from "./LiveValidator";
+import { StreamValidator } from "./StreamValidator";
+
+/**
+ * Real-time validation utilities
+ */
+export const Live = {
+  /**
+   * Create a reactive validator that validates in real-time
+   *
+   * @example
+   * ```typescript
+   * const UserSchema = Interface({
+   *   email: "email",
+   *   username: "string(3,20)",
+   *   password: "string(8,)"
+   * });
+   *
+   * const liveValidator = Live.validator(UserSchema);
+   *
+   * // Listen for validation changes
+   * liveValidator.onValidation((result) => {
+   *   console.log('Validation result:', result);
+   *   updateUI(result);
+   * });
+   *
+   * // Validate field by field
+   * liveValidator.validateField('email', 'user@example.com');
+   * liveValidator.validateField('username', 'johndoe');
+   *
+   * // Get current state
+   * console.log(liveValidator.isValid); // true/false
+   * console.log(liveValidator.errors);  // Current errors
+   * ```
+   */
+  validator(schema: SchemaInterface): LiveValidator {
+    return new LiveValidator(schema);
+  },
+
+  /**
+   * Create a form validator with field-level validation
+   *
+   * @example
+   * ```typescript
+   * const formValidator = Live.form(UserSchema);
+   *
+   * // Bind to form fields
+   * formValidator.bindField('email', emailInput);
+   * formValidator.bindField('username', usernameInput);
+   *
+   * // Auto-validation on input
+   * formValidator.enableAutoValidation();
+   *
+   * // Submit validation
+   * formValidator.onSubmit((isValid, data, errors) => {
+   *   if (isValid) {
+   *     submitForm(data);
+   *   } else {
+   *     showErrors(errors);
+   *   }
+   * });
+   * ```
+   */
+  form(schema: SchemaInterface): FormValidator {
+    return new FormValidator(schema);
+  },
+
+  /**
+   * Create a stream validator for continuous data validation
+   *
+   * @example
+   * ```typescript
+   * const streamValidator = Live.stream(DataSchema);
+   *
+   * // Validate streaming data
+   * dataStream.subscribe((data) => {
+   *   streamValidator.validate(data);
+   * });
+   *
+   * // Handle validation results
+   * streamValidator.onValid((data) => {
+   *   processValidData(data);
+   * });
+   *
+   * streamValidator.onInvalid((data, errors) => {
+   *   logInvalidData(data, errors);
+   * });
+   * ```
+   */
+  stream(schema: SchemaInterface): StreamValidator {
+    return new StreamValidator(schema);
+  },
+};
+
+/**
+ * Export all utilities
+ */
+export { LiveValidator, FormValidator, StreamValidator };
+export default Live;

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

@@ -0,0 +1,76 @@
+/**
+ * ReliantType Extensions - Advanced Features
+ *
+ * This module exports all advanced extensions that make ReliantType
+ * a powerful schema validation library.
+ *
+ * Features real, functional implementations without placeholders.
+ */
+
+import Docs from './components/AutoDocumentation';
+import When from './components/ConditionalValidation';
+import Live from './components/RealtimeValidation';
+import Smart from './SmartInference';
+
+// Import specialized utilities
+import { ValidationEngine } from './mods/validation-engine';
+import { OpenAPIConverter } from './mods/openapi-converter';
+import { TypeScriptGenerator } from './mods/typescript-generator';
+
+// Smart Inference - Automatic schema generation
+export { Smart } from './SmartInference';
+
+// Conditional Validation - Dependent field validation
+export { When, Extend } from './components/ConditionalValidation';
+
+// Real-time Validation - Live validation system (DOM features disabled for Node.js compatibility)
+export { Live, LiveValidator, StreamValidator } from './components/RealtimeValidation';
+
+// Auto Documentation - Automatic documentation generation
+export { Docs, DocumentationGenerator, SchemaAnalyzer, TypeScriptGenerator } from './components/AutoDocumentation';
+
+/**
+ * Extensions Bundle
+ *
+ * All extensions in one convenient object for easy access
+ */
+export const Extensions = {
+    Smart: { fromSample: Smart.fromSample, fromJsonSchema: Smart.fromJsonSchema, fromType: Smart.fromType },
+    When: { field: When.field, custom: When.custom },
+    Live: { validator: Live.validator, stream: Live.stream },
+    Docs: { generate: Docs.generate, typescript: Docs.typescript, openapi: Docs.openapi },
+
+    // Advanced utilities for specialized use cases
+    Utils: {
+        ValidationEngine,
+        OpenAPIConverter,
+        TypeScriptGenerator
+    }
+};
+
+/**
+ * Quick access to most commonly used extensions
+ */
+export const Quick = {
+    // Smart inference shortcuts
+    fromSample: Smart.fromSample,
+    fromJsonSchema: Smart.fromJsonSchema,
+
+    // Conditional validation shortcuts
+    when: When.field,
+
+    // Real-time validation shortcuts
+    live: Live.validator,
+    stream: Live.stream,
+
+    // Documentation shortcuts
+    docs: Docs.generate,
+    typescript: Docs.typescript,
+    openapi: Docs.openapi
+};
+
+
+/**
+ * Default export - Extensions bundle
+ */
+export default Extensions;

package/src/core/schema/extensions/mods/index.ts

@@ -0,0 +1,131 @@
+/**
+ *  Extensions Index - Centralized exports for all extension modules
+ * 
+ * This module provides a clean, organized way to access all extension
+ * functionality through specialized modules.
+ */
+
+import { OpenAPIConverter } from "./openapi-converter";
+import { TypeScriptGenerator } from "./typescript-generator";
+import { ValidationEngine } from "./validation-engine";
+
+// Core validation engine
+export { ValidationEngine } from "./validation-engine";
+export type { 
+    ValidationFieldResult, 
+    ValidationResult 
+} from "./validation-engine";
+
+// OpenAPI converter
+export { OpenAPIConverter } from "./openapi-converter";
+export type {
+    OpenAPISchemaObject,
+    OpenAPISpecOptions,
+    OpenAPISpecification,
+    OpenAPIReference,
+    RequestBodyOptions,
+    OpenAPIRequestBody,
+    ResponseOptions,
+    OpenAPIResponse
+} from "./openapi-converter";
+
+// TypeScript generator
+export { TypeScriptGenerator } from "./typescript-generator";
+export type {
+    TypeScriptOptions,
+    ModuleOptions
+} from "./typescript-generator";
+
+/**
+ *  Extensions Bundle
+ * 
+ * Provides easy access to all  extension functionality
+ */
+export const Extensions = {
+    /**
+     * Validation utilities
+     */
+    Validation: {
+        validateField: ValidationEngine.validateField,
+        validateObject: ValidationEngine.validateObject
+    },
+    
+    /**
+     * OpenAPI utilities
+     */
+    OpenAPI: {
+        convertSchema: OpenAPIConverter.convertSchema,
+        generateSpec: OpenAPIConverter.generateOpenAPISpec,
+        generateRequestBody: OpenAPIConverter.generateRequestBody,
+        generateResponse: OpenAPIConverter.generateResponse,
+        generateReference: OpenAPIConverter.generateSchemaReference
+    },
+    
+    /**
+     * TypeScript utilities
+     */
+    TypeScript: {
+        generateInterface: TypeScriptGenerator.generateInterface,
+        generateUtilityTypes: TypeScriptGenerator.generateUtilityTypes,
+        generateValidationTypes: TypeScriptGenerator.generateValidationTypes,
+        generateModule: TypeScriptGenerator.generateModule,
+        generateJSDoc: TypeScriptGenerator.generateJSDoc
+    }
+};
+
+/**
+ * Extension utilities for common use cases
+ */
+export const ExtensionUtils = {
+    /**
+     * Check if  extensions are available
+     */
+    isAvailable(): boolean {
+        return true;
+    },
+    
+    /**
+     * Get list of available  extensions
+     */
+    getAvailableModules(): string[] {
+        return ['ValidationEngine', 'OpenAPIConverter', 'TypeScriptGenerator'];
+    },
+    
+    /**
+     * Get extension version information
+     */
+    getVersionInfo(): ExtensionVersionInfo {
+        return {
+            version: '2.0.0',
+            architecture: '',
+            modules: {
+                ValidationEngine: '2.0.0',
+                OpenAPIConverter: '2.0.0', 
+                TypeScriptGenerator: '2.0.0'
+            },
+            features: [
+                ' architecture for better maintainability',
+                'Real validation engine with comprehensive type checking',
+                'Full OpenAPI 3.0 specification generation',
+                'Advanced TypeScript code generation',
+                'Utility type generation',
+                'JSDoc documentation generation'
+            ]
+        };
+    }
+};
+
+/**
+ * Type definitions
+ */
+interface ExtensionVersionInfo {
+    version: string;
+    architecture: string;
+    modules: Record<string, string>;
+    features: string[];
+}
+
+/**
+ * Default export -  Extensions bundle
+ */
+export default Extensions;