reliant-type 1.0.0 → 2.1.4

package/src/core/schema/mode/interfaces/Interface.ts

@@ -349,16 +349,4 @@ export { Mod } from "../../../utils/Mod";
  */
 export { Make } from "../../../utils/Make";
 
-/**
- * Custom error class for schema validation
- */
-export class SchemaValidationError extends Error {
-  constructor(
-    message: string,
-    public errors: string[],
-    public warnings: string[]
-  ) {
-    super(message);
-    this.name = "SchemaValidationError";
-  }
-}
+export { SchemaValidationError } from "./errors/SchemaValidationError";

package/src/core/schema/mode/interfaces/InterfaceSchema.ts

@@ -35,7 +35,7 @@ import {
   OptimizationLevel,
 } from "./precompilation/SchemaPrecompiler";
 import { MAX_OBJECT_DEPTH } from "../../../../constants/VALIDATION_CONSTANTS";
-import { SchemaValidationError } from "./Interface";
+import { SchemaValidationError } from "./errors/SchemaValidationError";
 import { ErrorCode } from "./errors/types/errors.type";
 
 /**
@@ -54,6 +54,46 @@ export class InterfaceSchema<T = any> {
   private precompiledValidator?: PrecompiledValidator;
   private optimizationLevel: OptimizationLevel = OptimizationLevel.NONE;
 
+  /**
+   * Static generator for TypeScript types
+   * This is set by the extension system to avoid circular dependencies
+   */
+  public static tsGenerator?: (definition: SchemaInterface, options?: SchemaOptions) => string;
+
+  /**
+   * Get the TypeScript type definition for this schema.
+   * At runtime, this returns the TypeScript interface/type as a string.
+   * For TypeScript, this property has the inferred type T.
+   * 
+   * @example
+   * ```typescript
+   * const UserSchema = Interface({ name: "string" });
+   * type User = typeof UserSchema.types;
+   * console.log(UserSchema.types); // Outputs the TS interface string
+   * ```
+   */
+  get types(): T {
+    if (InterfaceSchema.tsGenerator) {
+      return InterfaceSchema.tsGenerator(this.definition, this.options) as any;
+    }
+    
+    // Fallback: Generate a simple representation if generator not registered
+    let output = `export interface ${this.options.name || 'Schema'} {\n`;
+    for (const [key, value] of Object.entries(this.definition)) {
+      const isOptional = typeof value === 'string' && value.endsWith('?');
+      output += `  ${key}${isOptional ? '?' : ''}: any;\n`;
+    }
+    output += "}\n";
+    return output as any;
+  }
+
+  /**
+   * Alias for types property to support different coding styles
+   */
+  public getTypes(): T {
+    return this.types;
+  }
+
   constructor(
     private definition: SchemaInterface,
     private options: SchemaOptions = {}

package/src/core/schema/mode/interfaces/errors/SchemaValidationError.ts

@@ -0,0 +1,13 @@
+/**
+ * Custom error class for schema validation
+ */
+export class SchemaValidationError extends Error {
+  constructor(
+    message: string,
+    public errors: string[],
+    public warnings: string[] = []
+  ) {
+    super(message);
+    this.name = "SchemaValidationError";
+  }
+}

package/src/core/schema/mode/interfaces/precompilation/FieldPrecompilers.ts

@@ -703,6 +703,146 @@ export class FieldPrecompilers {
     return validator as CompiledFieldValidator;
   }
 
+  /**
+   * Precompile function field types (fn(() => void), etc.)
+   * ENHANCED: Implements function wrapping to validate arguments and return values at runtime.
+   */
+  static precompileFunction(functionType: string): CompiledFieldValidator {
+    const validator = (value: any): SchemaValidationResult => {
+      if (typeof value !== "function") {
+        return {
+          success: false,
+          errors: [ErrorHandler.createTypeError([], "function", value)],
+          warnings: [],
+          data: undefined,
+        };
+      }
+
+      // Extract signature: fn((args) => returnType)
+      const type = functionType.endsWith("?")
+        ? functionType.slice(0, -1)
+        : functionType;
+      const signature = type.slice(3, -1); // remove fn( and )
+
+      const arrowIndex = signature.lastIndexOf("=>");
+      if (arrowIndex === -1) {
+        return { success: true, errors: [], warnings: [], data: value };
+      }
+
+      const argsPart = signature.slice(0, arrowIndex).trim();
+      const returnPart = signature.slice(arrowIndex + 2).trim();
+
+      // Clean argsPart: remove outer parentheses if present
+      const cleanArgsPart =
+        argsPart.startsWith("(") && argsPart.endsWith(")")
+          ? argsPart.slice(1, -1)
+          : argsPart;
+
+      // Create a wrapped function that validates on call
+      const ReliantFunction = (...args: any[]) => {
+        // 1. Validate Arguments
+        if (cleanArgsPart && cleanArgsPart !== "()") {
+          const argDefs = cleanArgsPart.split(",").map((s) => s.trim());
+
+          for (let i = 0; i < argDefs.length; i++) {
+            const def = argDefs[i];
+            // Parse definition: name?: type or ...name: type
+            const parts = def.split(":");
+            const namePart = parts[0].trim();
+            let typePart = parts.slice(1).join(":").trim() || "any";
+
+            // Handle TYPE placeholder as any
+            if (typePart === "TYPE") typePart = "any";
+
+            const isRest = namePart.startsWith("...");
+            const isOptional = namePart.endsWith("?") || typePart.endsWith("?");
+
+            // Check for missing required arguments
+            // We check if the index exists in args. explicitly passing undefined is allowed if the type allows it,
+            // but not passing it at all is a missing argument error for required params.
+            if (!isRest && !isOptional && i >= args.length) {
+              throw new Error(
+                `[ReliantType] Missing required argument at index ${i} ('${namePart}'). Expected ${typePart}.`
+              );
+            }
+
+            if (isRest) {
+              const restType = typePart.endsWith("[]")
+                ? typePart.slice(0, -2)
+                : typePart;
+              const restArgs = args.slice(i);
+              const restValidator = FieldPrecompilers.parseAndCompile(restType);
+              for (const restArg of restArgs) {
+                const res = restValidator(restArg);
+                if (!res.success) {
+                  throw new Error(
+                    `[ReliantType] Argument validation failed for rest parameter at index ${i}: ${res.errors[0].message}`
+                  );
+                }
+              }
+              break; // Rest is always last
+            } else {
+              // If argument is provided (or undefined but present), validate it
+              if (i < args.length) {
+                const argValidator =
+                  FieldPrecompilers.parseAndCompile(typePart);
+                const res = argValidator(args[i]);
+                if (!res.success) {
+                  throw new Error(
+                    `[ReliantType] Argument validation failed for argument at index ${i} ('${namePart}'): ${res.errors[0].message}`
+                  );
+                }
+              }
+            }
+          }
+        }
+
+        // 2. Execute original function
+        const result = value(...args);
+
+        // 3. Validate Return Value
+        if (returnPart && returnPart !== "void") {
+          // Handle TYPE placeholder as any
+          const returnType = returnPart === "TYPE" ? "any" : returnPart;
+
+          if (returnType !== "any") {
+            const returnValidator =
+              FieldPrecompilers.parseAndCompile(returnType);
+            const res = returnValidator(result);
+            if (!res.success) {
+              throw new Error(
+                `[ReliantType] Return value validation failed for ${functionType}. Expected ${returnType}, got ${typeof result}: ${res.errors[0].message}`
+              );
+            }
+          }
+        }
+
+        return result;
+      };
+
+      // Force function name for better debugging
+      try {
+        Object.defineProperty(ReliantFunction, "name", {
+          value: `ReliantFunction_${functionType.replace(/[^a-zA-Z0-9]/g, "_")}`,
+          configurable: true,
+        });
+      } catch (e) {
+        /* ignore */
+      }
+
+      return {
+        success: true,
+        errors: [],
+        warnings: [],
+        data: ReliantFunction,
+      };
+    };
+
+    (validator as any)._fieldType = functionType;
+    (validator as any)._isCompiled = true;
+    return validator as CompiledFieldValidator;
+  }
+
   /**
    *  Precompile special field types (email, url, json, etc.)
    */
@@ -764,6 +904,12 @@ export class FieldPrecompilers {
       return isOptional ? this.precompileOptional(validator) : validator;
     }
 
+    // Handle function types (fn(() => void), etc.)
+    if (baseType.startsWith("fn(") && baseType.endsWith(")")) {
+      const validator = this.precompileFunction(baseType);
+      return isOptional ? this.precompileOptional(validator) : validator;
+    }
+
     // Handle basic types with constraints (including URL args like url.https)
     const constraintMatch = baseType.match(/^([\w.]+)(?:\(([^)]*)\))?$/);
     if (constraintMatch) {

package/src/core/schema/mode/interfaces/precompilation/SchemaPrecompiler.ts

@@ -16,6 +16,7 @@ import { MAX_COMPILATION_DEPTH as IMPORTED_MAX_COMPILATION_DEPTH } from "../../.
 import { ErrorHandler } from "../errors/ErrorHandler";
 import { ErrorCode } from "../errors/types/errors.type";
 import { SUPPORTED_VALIDATOR_TYPES } from "../../../../types/ValidatorTypes";
+import { TypeGuards } from "../validators/TypeGuards";
 
 // Precompiled validator function signature
 export interface PrecompiledValidator {
@@ -208,6 +209,22 @@ export class SchemaPrecompiler {
       // OPTIMIZED: Process simple fields first (fastest path)
       for (const field of simpleFields) {
         const value = data[field.fieldName];
+
+        // Handle optional fields
+        if (value === undefined) {
+          if (!field.isOptional) {
+            errors.push(
+              ErrorHandler.createMissingFieldError(
+                [field.fieldName],
+                field.fieldName
+              )
+            );
+          } else if (field.hasDefault) {
+            validatedData[field.fieldName] = field.defaultValue;
+          }
+          continue;
+        }
+
         const result = field.validator(value);
 
         if (!result.success) {
@@ -228,6 +245,22 @@ export class SchemaPrecompiler {
       // OPTIMIZED: Process union fields with precompiled validators
       for (const field of unionFields) {
         const value = data[field.fieldName];
+
+        // Handle optional fields
+        if (value === undefined) {
+          if (!field.isOptional) {
+            errors.push(
+              ErrorHandler.createMissingFieldError(
+                [field.fieldName],
+                field.fieldName
+              )
+            );
+          } else if (field.hasDefault) {
+            validatedData[field.fieldName] = field.defaultValue;
+          }
+          continue;
+        }
+
         const result = field.validator(value);
 
         if (!result.success) {
@@ -248,6 +281,22 @@ export class SchemaPrecompiler {
       // OPTIMIZED: Process array fields
       for (const field of arrayFields) {
         const value = data[field.fieldName];
+
+        // Handle optional fields
+        if (value === undefined) {
+          if (!field.isOptional) {
+            errors.push(
+              ErrorHandler.createMissingFieldError(
+                [field.fieldName],
+                field.fieldName
+              )
+            );
+          } else if (field.hasDefault) {
+            validatedData[field.fieldName] = field.defaultValue;
+          }
+          continue;
+        }
+
         const result = field.validator(value);
 
         if (!result.success) {
@@ -268,6 +317,22 @@ export class SchemaPrecompiler {
       // OPTIMIZED: Process nested fields last
       for (const field of nestedFields) {
         const value = data[field.fieldName];
+
+        // Handle optional fields
+        if (value === undefined) {
+          if (!field.isOptional) {
+            errors.push(
+              ErrorHandler.createMissingFieldError(
+                [field.fieldName],
+                field.fieldName
+              )
+            );
+          } else if (field.hasDefault) {
+            validatedData[field.fieldName] = field.defaultValue;
+          }
+          continue;
+        }
+
         const result = field.validator(value);
 
         if (!result.success) {
@@ -391,6 +456,20 @@ export class SchemaPrecompiler {
     options: SchemaOptions,
     depth: number = 0
   ): FieldCompilation {
+    // Handle OptionalSchemaInterface wrapper (used by Mod.deepPartial and Mod.makeOptional)
+    if (TypeGuards.isOptionalSchemaInterface(fieldType)) {
+      const compilation = this.compileField(
+        fieldName,
+        fieldType.schema,
+        options,
+        depth
+      );
+      return {
+        ...compilation,
+        isOptional: true,
+      };
+    }
+
     // Handle nested objects properly
     if (
       typeof fieldType === "object" &&

package/src/core/schema/mode/interfaces/typescript/TypeInference.ts

@@ -53,16 +53,20 @@ export type CoreTypeMap = {
 
   // Special types
   unknown: unknown;
-  void: undefined;
+  void: void;
   null: null;
   undefined: undefined;
+  TYPE: any;
 };
 
 /**
  * Extract base type from field type string (removes constraints and modifiers)
  */
-export type ExtractBaseType<T extends string> =
-  T extends `${infer Base}(${string})`
+export type ExtractBaseType<T extends string> = T extends
+  | `fn(${infer Sig})`
+  | `fn(${infer Sig})?`
+  ? `fn(${Sig})`
+  : T extends `${infer Base}(${string})`
     ? Base
     : T extends `${infer Base}?`
       ? Base
@@ -139,19 +143,22 @@ export type MapFieldType<T extends string> =
         : // Handle conditional expressions (contains "when" and "*?")
           T extends `when ${string} *? ${string}`
           ? InferConditionalType<T>
-          : // Handle union types (contains |) - check after removing optional and parentheses
-            ExtractBaseType<T> extends `${string}|${string}`
-            ? ParseUnionType<ExtractBaseType<T>>
-            : // Handle constant types (starts with =)
-              T extends `=${infer Value}?`
-              ? Value | undefined
-              : T extends `=${infer Value}`
-                ? Value
-                : // Handle core types
-                  ExtractBaseType<T> extends keyof CoreTypeMap
-                  ? CoreTypeMap[ExtractBaseType<T>]
-                  : // Fallback to any for unknown types
-                    any;
+          : // Handle function types (fn((args) => void))
+            ExtractBaseType<T> extends `fn(${infer Sig})`
+            ? ParseFunctionType<Sig>
+            : // Handle union types (contains |) - check after removing optional and parentheses
+              ExtractBaseType<T> extends `${string}|${string}`
+              ? ParseUnionType<ExtractBaseType<T>>
+              : // Handle constant types (starts with =)
+                T extends `=${infer Value}?`
+                ? Value | undefined
+                : T extends `=${infer Value}`
+                  ? Value
+                  : // Handle core types
+                    ExtractBaseType<T> extends keyof CoreTypeMap
+                    ? CoreTypeMap[ExtractBaseType<T>]
+                    : // Fallback to any for unknown types
+                      any;
 
 /**
  * Utility type to trim whitespace from string literal types
@@ -174,6 +181,50 @@ export type ParseUnionType<T extends string> =
       ? Trim<First> | ParseUnionType<Rest>
       : Trim<T>;
 
+/**
+ * Parse function signature string into a real TypeScript function type
+ */
+export type ParseFunctionType<S extends string> =
+  S extends `(${infer Args}) => ${infer Return}`
+    ? (...args: ParseArgs<Args>) => ParseReturnType<Return>
+    : S extends `${infer Args} => ${infer Return}`
+      ? (...args: ParseArgs<Args>) => ParseReturnType<Return>
+      : (...args: any[]) => any;
+
+/**
+ * Parse return type of a function
+ */
+export type ParseReturnType<T extends string> =
+  Trim<T> extends "void"
+    ? void
+    : Trim<T> extends "TYPE"
+      ? any
+      : MapFieldType<Trim<T>>;
+
+/**
+ * Parse arguments of a function into a tuple
+ */
+export type ParseArgs<T extends string> =
+  Trim<T> extends ""
+    ? []
+    : Trim<T> extends `${infer First},${infer Rest}`
+      ? [...ParseArgAsTuple<First>, ...ParseArgs<Rest>]
+      : ParseArgAsTuple<T>;
+
+/**
+ * Parse a single argument into a tuple element (handles rest parameters)
+ */
+export type ParseArgAsTuple<T extends string> =
+  Trim<T> extends `${infer Name}:${infer Type}`
+    ? Name extends `...${infer RestName}`
+      ? MapFieldType<Trim<Type>> extends (infer U)[]
+        ? [...args: U[]]
+        : [...args: any[]]
+      : Name extends `${infer ArgName}?`
+        ? [arg?: MapFieldType<Trim<Type>> | undefined]
+        : [arg: MapFieldType<Trim<Type>>]
+    : [any];
+
 /**
  * Handle optional fields
  */

package/src/core/schema/mode/interfaces/validators/ConstraintParser.ts

@@ -80,6 +80,9 @@ export class ConstraintParser {
 
     // Colon split for key-value pairs
     colonSplit: /\s*:\s*/,
+
+    // Function type detection
+    functionType: /^fn\(.*\)$/,
   } as const;
 
   // Character codes for optimized checks
@@ -201,6 +204,11 @@ export class ConstraintParser {
       return { type, constraints: {}, optional, required };
     }
 
+    // Handle function types (fn(() => void), etc.)
+    if (this._patterns.functionType.test(type)) {
+      return { type, constraints: {}, optional, required };
+    }
+
     // Enhanced constraint parsing with robust validation
     const constraintMatch = this._parseBalancedConstraints(type);
     if (constraintMatch) {

package/src/core/schema/mode/interfaces/validators/TypeGuards.ts

@@ -1,6 +1,6 @@
 /**
  * Type Guards Module
- * 
+ *
  * Contains all type guard functions extracted from InterfaceSchema
  * to improve maintainability and reduce file size.
  */
@@ -12,7 +12,7 @@ import {
   OptionalSchemaInterface,
   UnionValue,
 } from "../../../../types/SchemaValidator.type";
- 
+
 /**
  * Type guard functions for schema validation
  */
@@ -33,7 +33,9 @@ export class TypeGuards {
   /**
    * Check if value is a constant value
    */
-  static isConstantValue(value: any): value is ConstantValue | OptionalConstantValue {
+  static isConstantValue(
+    value: any
+  ): value is ConstantValue | OptionalConstantValue {
     return (
       typeof value === "object" &&
       value !== null &&
@@ -45,7 +47,9 @@ export class TypeGuards {
   /**
    * Check if value is an optional schema interface
    */
-  static isOptionalSchemaInterface(value: any): value is OptionalSchemaInterface {
+  static isOptionalSchemaInterface(
+    value: any
+  ): value is OptionalSchemaInterface {
     return (
       typeof value === "object" &&
       value !== null &&
@@ -137,6 +141,14 @@ export class TypeGuards {
     return fieldType.startsWith("record<") && fieldType.endsWith(">");
   }
 
+  /**
+   * Check if string is a function type
+   */
+  static isFunctionType(fieldType: string): boolean {
+    const type = fieldType.endsWith("?") ? fieldType.slice(0, -1) : fieldType;
+    return type.startsWith("fn(") && type.endsWith(")");
+  }
+
   /**
    * Check if string has constraints (contains parentheses)
    */
@@ -184,7 +196,9 @@ export class TypeGuards {
    * Check if value is a valid UUID format
    */
   static isValidUuid(value: string): boolean {
-    return /^[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i.test(value);
+    return /^[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i.test(
+      value
+    );
   }
 
   /**

package/src/core/schema/mode/interfaces/validators/mods/securityValidator.ts

@@ -44,7 +44,7 @@ export class SecurityValidators {
       // security schema with more comprehensive protections
       this.ajv.addSchema(
         {
-          $id: "https://nehonix.space/lib/v/reliant-type",
+          $id: "https://nehonix.com/lib/v/reliant-type",
           type: ["object", "array", "string", "number", "boolean", "null"],
           definitions: {
             secureObject: {

package/src/core/types/SchemaValidator.type.ts

@@ -189,6 +189,10 @@ export interface SchemaOptions {
   enableOptimizations?: boolean;
   cacheValidation?: boolean;
   skipOptimization?: boolean; // Skip optimization to prevent circular dependency
+
+  // Metadata options
+  name?: string;
+  description?: string;
 }
 
 // Helper type for schemas that allow unknown properties

package/src/core/utils/Mod.ts

@@ -176,8 +176,22 @@ export class Mod {
 
     const partialDefinition: SchemaInterface = {};
     for (const [key, value] of Object.entries(definition)) {
-      if (typeof value === "string" && !value.endsWith("?")) {
-        partialDefinition[key] = value + "?";
+      if (typeof value === "string") {
+        partialDefinition[key] = value.endsWith("?") ? value : value + "?";
+      } else if (
+        typeof value === "object" &&
+        value !== null &&
+        !Array.isArray(value)
+      ) {
+        // For objects, wrap in optional schema interface if not already optional
+        if ("optional" in value && (value as any).optional === true) {
+          partialDefinition[key] = value;
+        } else {
+          partialDefinition[key] = {
+            schema: value,
+            optional: true,
+          };
+        }
       } else {
         partialDefinition[key] = value;
       }
@@ -195,8 +209,25 @@ export class Mod {
 
     const requiredDefinition: SchemaInterface = {};
     for (const [key, value] of Object.entries(definition)) {
-      if (typeof value === "string" && value.endsWith("?")) {
-        requiredDefinition[key] = value.slice(0, -1);
+      if (typeof value === "string") {
+        requiredDefinition[key] = value.endsWith("?")
+          ? value.slice(0, -1)
+          : value;
+      } else if (
+        typeof value === "object" &&
+        value !== null &&
+        !Array.isArray(value)
+      ) {
+        // Unwrap optional schema interface if present
+        if (
+          "optional" in value &&
+          (value as any).optional === true &&
+          "schema" in value
+        ) {
+          requiredDefinition[key] = (value as any).schema;
+        } else {
+          requiredDefinition[key] = value;
+        }
       } else {
         requiredDefinition[key] = value;
       }

package/src/index.ts

@@ -122,3 +122,12 @@ export type {
   SchemaType,
   SchemaConfig,
 } from "./core/types/types";
+import { InterfaceSchema } from "./core/schema/mode/interfaces/InterfaceSchema";
+import { TSGenerator } from "./core/schema/extensions/mods/typescript-generator";
+
+// Register the TypeScript generator for InterfaceSchema to enable .types property
+InterfaceSchema.tsGenerator = (definition, options) => {
+  return TSGenerator.generateInterface(definition, {
+    exportName: options?.name || "Schema"
+  });
+};