reliant-type 1.0.0

package/src/core/schema/extensions/mods/validation-engine.ts

@@ -0,0 +1,295 @@
+/**
+ * Validation Engine - Core validation logic for schema extensions
+ *
+ * This module provides the core validation engine that powers all schema extensions.
+ * It acts as a bridge between extensions and the main validation system, delegating
+ * actual validation to the TypeValidators module to avoid duplication.
+ */
+
+import { SchemaInterface } from "../../mode/interfaces/Interface";
+import { TypeValidators } from "../../mode/interfaces/validators/TypeValidators";
+import { ConstraintParser } from "../../mode/interfaces/validators/ConstraintParser";
+import { TypeGuards } from "../../mode/interfaces/validators/TypeGuards";
+import { ValidationHelpers } from "../../mode/interfaces/validators/ValidationHelpers";
+import { ErrorHandler } from "../../mode/interfaces/errors/ErrorHandler";
+import { SchemaOptions } from "../../../types/SchemaValidator.type";
+import { ErrorCode } from "../../mode/interfaces/errors/types/errors.type";
+
+/**
+ * Core validation engine for schema validation
+ */
+export class ValidationEngine {
+  /**
+   * Validate a value against a schema field definition
+   * Delegates to TypeValidators for actual validation logic
+   */
+  static validateField(fieldSchema: any, value: any): ValidationFieldResult {
+    if (typeof fieldSchema === "string") {
+      return this.validateStringSchema(fieldSchema, value);
+    }
+
+    if (typeof fieldSchema === "object" && !Array.isArray(fieldSchema)) {
+      return this.validateObjectSchema(fieldSchema, value);
+    }
+
+    // Default: accept any value
+    return { isValid: true, errors: [] };
+  }
+
+  /**
+   * Validate against string-based schema definitions
+   * Uses TypeValidators for consistent validation logic
+   */
+  private static validateStringSchema(
+    fieldSchema: string,
+    value: any
+  ): ValidationFieldResult {
+    // Parse the field schema using ConstraintParser
+    const parsed = ConstraintParser.parseConstraints(fieldSchema);
+    const { type, constraints, optional } = parsed;
+
+    // Handle null/undefined for optional fields
+    if (optional && (value === null || value === undefined)) {
+      return { isValid: true, errors: [] };
+    }
+
+    // Required field cannot be null/undefined
+    if (!optional && (value === null || value === undefined)) {
+      return {
+        isValid: false,
+        errors: [`Field is required but received ${value}`],
+      };
+    }
+
+    // Use TypeValidators for actual validation
+    const options: SchemaOptions = { loose: false }; // Default options
+    let validationResult;
+
+    try {
+      // Delegate to appropriate TypeValidator method based on type
+      switch (type) {
+        case "string":
+          validationResult = TypeValidators.validateString(
+            value,
+            options,
+            constraints
+          );
+          break;
+        case "number":
+        case "float":
+        case "double":
+          validationResult = TypeValidators.validateNumber(
+            value,
+            options,
+            constraints
+          );
+          break;
+        case "int":
+        case "integer":
+        case "positive":
+        case "negative":
+          validationResult = TypeValidators.validateInteger(
+            value,
+            options,
+            constraints,
+            type as any
+          );
+          break;
+        case "boolean":
+          validationResult = TypeValidators.validateBoolean(value, options, {});
+          break;
+        case "date":
+          validationResult = TypeValidators.validateDate(
+            value,
+            options,
+            {},
+            "date"
+          );
+          break;
+        case "email":
+          validationResult = TypeValidators.validateEmail(value);
+          break;
+        case "url":
+          validationResult = TypeValidators.validateUrl(value, "url.web");
+          break;
+        case "uuid":
+        case "guid":
+          validationResult = TypeValidators.validateUuid(value, type as any);
+          break;
+        default:
+          // Handle arrays and other complex types
+          if (type.includes("[]")) {
+            // For arrays, use ValidationHelpers.validateArrayWithConstraints
+            const elementType = type.replace("[]", "");
+            validationResult = ValidationHelpers.validateArrayWithConstraints(
+              value,
+              elementType,
+              constraints,
+              (elemType: string, elemValue: any) => {
+                // Recursively validate each element and convert result format
+                const fieldResult = this.validateStringSchema(
+                  elemType,
+                  elemValue
+                );
+                // Convert string errors to ValidationError objects
+                const validationErrors = fieldResult.errors.map((errorMsg) => {
+                  if (typeof errorMsg === "string") {
+                    // console.log("converting string error to ValidationError");
+                    return ErrorHandler.convertStringToError(errorMsg, ErrorCode.VALIDATION_ERROR
+                    );
+                  }
+                  // If it's already a ValidationError object, return as is
+                  if (
+                    errorMsg &&
+                    typeof errorMsg === "object" &&
+                    "message" in errorMsg
+                  ) {
+                    return errorMsg as any;
+                  }
+                  // Fallback: convert to string and then to ValidationError
+                  // console.log(
+                  //   "converting unknown error format to ValidationError"
+                  // );
+                  return ErrorHandler.convertStringToError(
+                    String(errorMsg),
+                    ErrorCode.VALIDATION_ERROR
+                  );
+                });
+                return {
+                  success: fieldResult.isValid,
+                  errors: validationErrors,
+                  warnings: [],
+                  data: elemValue,
+                };
+              }
+            );
+          } else {
+            // // Unknown type - accept any value
+            validationResult = {
+              success: true,
+              errors: [],
+              warnings: [],
+              data: value,
+            };
+          }
+      }
+
+      // Convert TypeValidators result format to ValidationEngine format
+      return {
+        isValid: validationResult.success,
+        errors: (validationResult.errors || []).map((error) => {
+          if (typeof error === "string") {
+            return error;
+          }
+          if (error && typeof error === "object" && error.message) {
+            return error.message;
+          }
+          // Fallback: try to extract meaningful information
+          if (error && typeof error === "object") {
+            if (
+              error.toString &&
+              error.toString !== Object.prototype.toString
+            ) {
+              return error.toString();
+            }
+            return JSON.stringify(error);
+          }
+          return String(error);
+        }),
+      };
+    } catch (error) {
+      return {
+        isValid: false,
+        errors: [
+          `Validation error: ${error instanceof Error ? error.message : "Unknown error"}`,
+        ],
+      };
+    }
+  }
+
+  /**
+   * Validate against object schema definitions
+   */
+  private static validateObjectSchema(
+    fieldSchema: any,
+    value: any
+  ): ValidationFieldResult {
+    const errors: string[] = [];
+
+    if (typeof value !== "object" || value === null) {
+      errors.push("Expected object but received " + typeof value);
+      return { isValid: false, errors };
+    }
+
+    // Validate all nested fields
+    for (const [nestedField, nestedSchema] of Object.entries(fieldSchema)) {
+      const nestedResult = this.validateField(nestedSchema, value[nestedField]);
+      if (!nestedResult.isValid) {
+        const errRes = nestedResult.errors.map((err) => {
+          // Handle both string and ValidationError object cases
+          const errorMessage =
+            typeof err === "string"
+              ? err
+              : err && typeof err === "object" && "message" in err
+                ? (err as any).message
+                : JSON.stringify(err);
+          return `${nestedField}: ${errorMessage}`;
+        });
+        errors.push(...errRes);
+      }
+    }
+
+    return { isValid: errors.length === 0, errors };
+  }
+
+  // All individual validation methods removed - now delegated to TypeValidators
+
+  /**
+   * Validate entire object against schema
+   */
+  static validateObject(schema: SchemaInterface, data: any): ValidationResult {
+    const errors: Record<string, string[]> = {};
+    let isValid = true;
+
+    if (!data || typeof data !== "object") {
+      return {
+        isValid: false,
+        data,
+        errors: { _root: ["Expected object but received " + typeof data] },
+        timestamp: new Date(),
+      };
+    }
+
+    // Validate each field in the schema
+    for (const [fieldName, fieldSchema] of Object.entries(schema)) {
+      const fieldResult = this.validateField(fieldSchema, data[fieldName]);
+
+      if (!fieldResult.isValid) {
+        errors[fieldName] = fieldResult.errors;
+        isValid = false;
+      }
+    }
+
+    return {
+      isValid,
+      data,
+      errors,
+      timestamp: new Date(),
+    };
+  }
+}
+
+/**
+ * Type definitions
+ */
+export interface ValidationFieldResult {
+  isValid: boolean;
+  errors: string[];
+}
+
+export interface ValidationResult {
+  isValid: boolean;
+  data: any;
+  errors: Record<string, string[]>;
+  timestamp: Date;
+}

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

@@ -0,0 +1,364 @@
+/**
+ * TypeScript Interface-like Schema System
+ *
+ * The most intuitive way to define schemas - just like TypeScript interfaces!
+ *
+ * @example
+ * ```typescript
+ * import { Interface as IF} from "reliant-type";
+ *
+ * // Define schema like a TypeScript interface
+ * const UserSchema = IF({
+ *   id: "number",
+ *   email: "email",
+ *   name: "string",
+ *   age: "number?",           // Optional
+ *   isActive: "boolean?",     // Optional
+ *   tags: "string[]?",        // Optional array
+ *   role: "admin",            // Constant value
+ *   profile: {                // Nested object
+ *     bio: "string?",
+ *     avatar: "url?"
+ *   }
+ * });
+ *
+ * // Validate data
+ * const result = UserSchema.safeParse(userData);
+ * ```
+ */
+
+import { InterfaceSchema } from "./InterfaceSchema";
+import {
+  ConstantValue,
+  OptionalConstantValue,
+  OptionalSchemaInterface,
+  SchemaInterface,
+  SchemaOptions,
+  SchemaFieldType,
+  UnionValue,
+} from "../../../types/SchemaValidator.type";
+import { InferSchemaType } from "./typescript/TypeInference";
+
+/**
+ * Convert Make objects to string syntax that InterfaceSchema understands
+ */
+function convertMakeObjectsToStrings(definition: any): any {
+  if (typeof definition !== "object" || definition === null) {
+    return definition;
+  }
+
+  // Handle arrays
+  if (Array.isArray(definition)) {
+    return definition.map((item) => convertMakeObjectsToStrings(item));
+  }
+
+  // Check if this is a Make.const() object: convert => =constVal
+  if (
+    typeof definition === "object" &&
+    "const" in definition &&
+    Object.keys(definition).length === 1
+  ) {
+    // Convert Make.const() to string syntax
+    return `=${definition.const}`;
+  }
+
+  // Check if this is a Make.union() object
+  if (
+    typeof definition === "object" &&
+    "union" in definition &&
+    Array.isArray(definition.union)
+  ) {
+    // Check if it's an optional union (Make.unionOptional)
+    if ("optional" in definition && definition.optional === true) {
+      // Convert Make.unionOptional() to string syntax with "?" suffix
+      return definition.union.join("|") + "?";
+    } else {
+      // Convert Make.union() to string syntax
+      return definition.union.join("|");
+    }
+  }
+
+  // Recursively process nested objects
+  const result: any = {};
+  for (const [key, value] of Object.entries(definition)) {
+    result[key] = convertMakeObjectsToStrings(value);
+  }
+  return result;
+}
+
+/**
+ * Create a schema using TypeScript interface-like syntax with full type inference
+ *
+ * @param definition - Schema definition using TypeScript-like syntax
+ * @param options - Optional validation options
+ * @returns InterfaceSchema instance with inferred types
+ *
+ * @example Basic Usage
+ * ```typescript
+ * const UserSchema = Interface({
+ *   id: "number",
+ *   email: "email",
+ *   name: "string",
+ *   age: "number?",
+ *   isActive: "boolean?",
+ *   tags: "string[]?"
+ * });
+ *
+ * // result is fully typed as:
+ * // SchemaValidationResult<{
+ * //   id: number;
+ * //   email: string;
+ * //   name: string;
+ * //   age?: number;
+ * //   isActive?: boolean;
+ * //   tags?: string[];
+ * // }>
+ * const result = UserSchema.safeParse(data);
+ * ```
+ *
+ * @example With Constraints
+ * ```typescript
+ * const UserSchema = Interface({
+ *   username: "string(3,20)",        // 3-20 characters
+ *   age: "number(18,120)",           // 18-120 years
+ *   tags: "string[](1,10)?",         // 1-10 tags, optional
+ * });
+ * ```
+ *
+ * @example Nested Objects
+ * ```typescript
+ * const OrderSchema = Interface({
+ *   id: "number",
+ *   customer: {
+ *     name: "string",
+ *     email: "email",
+ *     address: {
+ *       street: "string",
+ *       city: "string",
+ *       zipCode: "string"
+ *     }
+ *   },
+ *   items: [{
+ *     name: "string",
+ *     price: "number",
+ *     quantity: "int"
+ *   }]
+ * });
+ * ``` 
+ */
+export function Interface<const T extends SchemaInterface>(
+  definition: T,
+  options?: SchemaOptions
+): InterfaceSchema<InferSchemaType<T>> {
+  // Convert Make objects to string syntax before creating schema
+  const processedDefinition = convertMakeObjectsToStrings(definition);
+
+  // Debug: Log the conversion (disabled for now)
+  // if (process.env.NODE_ENV !== "production") {
+  //   console.log("DEBUG: Original definition:", JSON.stringify(definition, null, 2));
+  //   console.log("DEBUG: Processed definition:", JSON.stringify(processedDefinition, null, 2));
+  // }
+
+  return new InterfaceSchema<InferSchemaType<T>>(processedDefinition, options);
+}
+
+/**
+ * Type helper for inferring TypeScript types from schema definitions
+ *
+ * @example
+ * ```typescript
+ * const UserSchema = Interface({
+ *   id: "number",
+ *   email: "email",
+ *   name: "string",
+ *   age: "number?",
+ *   tags: "string[]?"
+ * });
+ *
+ * // Infer the TypeScript type
+ * type User = InferType<typeof UserSchema>;
+ * // User = {
+ * //   id: number;
+ * //   email: string;
+ * //   name: string;
+ * //   age?: number;
+ * //   tags?: string[];
+ * // }
+ * ```
+ */
+export type InferType<T extends InterfaceSchema<any>> =
+  T extends InterfaceSchema<infer U> ? U : never;
+
+// Export the main inference type for direct use
+export type { InferSchemaType };
+
+// Re-export types for convenience
+export type {
+  SchemaInterface,
+  SchemaOptions,
+  SchemaFieldType,
+  ConstantValue,
+} from "../../../types/SchemaValidator.type";
+export { InterfaceSchema } from "./InterfaceSchema";
+
+// Re-export TypeScript integration
+export { TypeScriptIntegration, IDE, TypeInference } from "./typescript";
+export type {
+  ConditionalExpression,
+  TypeInferenceResult,
+  ConditionalResult,
+  FieldPaths,
+  GetValueByPath,
+  ValidateConditional,
+} from "./typescript";
+
+// Re-export validators for advanced usage
+export {
+  TypeValidators,
+  ConstraintParser,
+  TypeGuards,
+  ValidationHelpers,
+} from "./validators"; 
+export type { ParsedConstraints } from "./validators";
+
+/**
+ * Available field types for schema definitions
+ */
+export const FieldTypes = {
+  // Basic types
+  STRING: "string" as const,
+  STRING_OPTIONAL: "string?" as const,
+  NUMBER: "number" as const,
+  NUMBER_OPTIONAL: "number?" as const,
+  BOOLEAN: "boolean" as const,
+  BOOLEAN_OPTIONAL: "boolean?" as const,
+  DATE: "date" as const,
+  DATE_OPTIONAL: "date?" as const,
+  ANY: "any" as const,
+  ANY_OPTIONAL: "any?" as const,
+
+  // String formats
+  EMAIL: "email" as const,
+  EMAIL_OPTIONAL: "email?" as const,
+  URL: "url" as const,
+  URL_OPTIONAL: "url?" as const,
+  UUID: "uuid" as const,
+  UUID_OPTIONAL: "uuid?" as const,
+  PHONE: "phone" as const,
+  PHONE_OPTIONAL: "phone?" as const,
+  SLUG: "slug" as const,
+  SLUG_OPTIONAL: "slug?" as const,
+  USERNAME: "username" as const,
+  USERNAME_OPTIONAL: "username?" as const,
+
+  // Number types
+  INT: "int" as const,
+  INT_OPTIONAL: "int?" as const,
+  POSITIVE: "positive" as const,
+  POSITIVE_OPTIONAL: "positive?" as const,
+  FLOAT: "float" as const,
+  FLOAT_OPTIONAL: "float?" as const,
+
+  // Array types
+  STRING_ARRAY: "string[]" as const,
+  STRING_ARRAY_OPTIONAL: "string[]?" as const,
+  NUMBER_ARRAY: "number[]" as const,
+  NUMBER_ARRAY_OPTIONAL: "number[]?" as const,
+  BOOLEAN_ARRAY: "boolean[]" as const,
+  BOOLEAN_ARRAY_OPTIONAL: "boolean[]?" as const,
+  INT_ARRAY: "int[]" as const,
+  INT_ARRAY_OPTIONAL: "int[]?" as const,
+  EMAIL_ARRAY: "email[]" as const,
+  EMAIL_ARRAY_OPTIONAL: "email[]?" as const,
+  URL_ARRAY: "url[]" as const,
+  URL_ARRAY_OPTIONAL: "url[]?" as const,
+
+  // Record types
+  RECORD_STRING_ANY: "record<string,any>" as const,
+  RECORD_STRING_ANY_OPTIONAL: "record<string,any>?" as const,
+  RECORD_STRING_STRING: "record<string,string>" as const,
+  RECORD_STRING_STRING_OPTIONAL: "record<string,string>?" as const,
+  RECORD_STRING_NUMBER: "record<string,number>" as const,
+  RECORD_STRING_NUMBER_OPTIONAL: "record<string,number>?" as const,
+} as const;
+
+/**
+ * Quick schema creation helpers
+ */
+export const QuickSchemas = {
+  /**
+   * User schema with common fields
+   */
+  User: Interface({
+    id: "number",
+    email: "email",
+    name: "string",
+    createdAt: "date?",
+    updatedAt: "date?",
+  }),
+
+  /**
+   * API response schema
+   */
+  APIResponse: Interface({
+    success: "boolean",
+    data: "any?",
+    errors: "string[]?",
+    timestamp: "date?",
+  }),
+
+  /**
+   * Pagination schema
+   */
+  Pagination: Interface({
+    page: "int",
+    limit: "int",
+    total: "int",
+    hasNext: "boolean?",
+    hasPrev: "boolean?",
+  }),
+
+  /**
+   * Address schema
+   */
+  Address: Interface({
+    street: "string",
+    city: "string",
+    state: "string?",
+    zipCode: "string",
+    country: "string",
+  }),
+
+  /**
+   * Contact info schema
+   */
+  Contact: Interface({
+    email: "email?",
+    phone: "phone?",
+    website: "url?",
+  }),
+};
+
+/**
+ * Schema modification utilities - transform and combine schemas
+ */
+export { Mod } from "../../../utils/Mod";
+
+/**
+ * Helper functions for creating schema values
+ */
+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";
+  }
+}