reliant-type 1.0.0

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

@@ -0,0 +1,210 @@
+import { ConditionalNode } from "../schema/mode/interfaces/conditional/types/ConditionalTypes";
+
+/**
+ * Constant value wrapper to distinguish from string types
+ */
+export interface ConstantValue {
+  const: string | number | boolean;
+}
+
+/**
+ * Union value wrapper for proper type inference
+ */
+export interface UnionValue<T extends readonly string[] = readonly string[]> {
+  union: T;
+}
+
+/**
+ * Optional constant value wrapper
+ */
+export interface OptionalConstantValue {
+  const: string | number | boolean;
+  optional: true;
+}
+
+/**
+ * Optional schema interface wrapper
+ */
+export interface OptionalSchemaInterface {
+  optional: true;
+  schema: SchemaInterface;
+}
+
+/**
+ * Schema definition using TypeScript-like interface syntax
+ */
+export interface SchemaInterface {
+  [key: string]:
+    | SchemaFieldType
+    | ConstantValue
+    | OptionalConstantValue
+    | SchemaInterface
+    | SchemaInterface[]
+    | any;
+}
+
+/**
+ * Field type definitions using string literals and objects
+ */
+export type SchemaFieldType =
+  // Basic types
+  | "string"
+  | "string?"
+  | "number"
+  | "number?"
+  | "boolean"
+  | "boolean?"
+  | "date"
+  | "date?"
+  | "any"
+  | "any?"
+
+  // String formats
+  | "email"
+  | "email?"
+  | "url"
+  | "url?"
+  | "uuid"
+  | "uuid?"
+  | "phone"
+  | "phone?"
+  | "slug"
+  | "slug?"
+  | "username"
+  | "username?"
+  | "ip"
+  | "ip?"
+  | "json"
+  | "json?"
+  | "json.fast"
+  | "json.fast?"
+  | "json.secure"
+  | "json.secure?"
+  | "password"
+  | "password?"
+  | "text"
+  | "text?"
+  | "hexcolor"
+  | "hexcolor?"
+  | "base64"
+  | "base64?"
+  | "jwt"
+  | "jwt?"
+  | "semver"
+  | "semver?"
+
+  // Object types
+  | "object"
+  | "object?"
+
+  // Number types
+  | "int"
+  | "int?"
+  | "positive"
+  | "positive?"
+  | "float"
+  | "float?"
+
+  // Array types
+  | "string[]"
+  | "string[]?"
+  | "number[]"
+  | "number[]?"
+  | "boolean[]"
+  | "boolean[]?"
+  | "int[]"
+  | "int[]?"
+  | "email[]"
+  | "email[]?"
+  | "url[]"
+  | "url[]?"
+  | "ip[]"
+  | "ip[]?"
+  | "json[]"
+  | "json[]?"
+  | "json.fast[]"
+  | "json.fast[]?"
+  // | "json.secure[]"
+  // | "json.secure[]?"
+  | "password[]"
+  | "password[]?"
+  | "text[]"
+  | "text[]?"
+  | "object[]"
+  | "object[]?"
+  | "hexcolor[]"
+  | "hexcolor[]?"
+  | "base64[]"
+  | "base64[]?"
+  | "jwt[]"
+  | "jwt[]?"
+  | "semver[]"
+  | "semver[]?"
+
+  // Union types (multiple allowed values)
+  | string // For union syntax like "pending|accepted|rejected"
+
+  // Constant values
+  | ConstantValue
+  | OptionalConstantValue
+
+  // Union values
+  | UnionValue
+
+  // Nested objects and arrays
+  | SchemaInterface
+  | SchemaInterface[]
+  | OptionalSchemaInterface;
+
+/**
+ * Schema validation options for fine-tuning
+ */
+export interface SchemaOptions {
+  // String options
+  minLength?: number;
+  maxLength?: number;
+  pattern?: RegExp;
+
+  // Number options
+  min?: number;
+  max?: number;
+  precision?: number;
+
+  // Array options
+  minItems?: number;
+  maxItems?: number;
+  unique?: boolean;
+
+  // Object options
+  strict?: boolean;
+  allowUnknown?: boolean;
+
+  // General options
+  required?: boolean;
+  default?: any;
+  loose?: boolean; // Allow type coercion (opposite of strict)
+
+  // Performance options
+  enablePerformanceMonitoring?: boolean;
+  enableOptimizations?: boolean;
+  cacheValidation?: boolean;
+  skipOptimization?: boolean; // Skip optimization to prevent circular dependency
+}
+
+// Helper type for schemas that allow unknown properties
+export type AllowUnknownSchema<T> = T & Record<string, any>;
+
+// Pre-compiled field definition for faster validation
+export interface CompiledField {
+  key: string;
+  originalType: SchemaFieldType;
+  isString: boolean;
+  isConditional: boolean;
+  conditionalConfig?: any;
+  parsedConstraints?: any;
+  isArray?: boolean;
+  elementType?: string;
+  isOptional?: boolean;
+  // conditional validation
+  ConditionalAST?: ConditionalNode;
+}

package/src/core/types/ValidatorTypes.ts

@@ -0,0 +1,93 @@
+import { createEnum } from "../utils/arrayToEnum";
+import { UrlArgArray } from "../utils/UrlArgs";
+
+export const SUPPORTED_VALIDATOR_TYPES = [
+  "string",
+  "number",
+  "float",
+  "int",
+  "integer",
+  "positive",
+  "negative",
+  "double",
+  "boolean",
+  "bool",
+  "date",
+  "datetime",
+  "timestamp",
+  "email",
+  "uuid",
+  "guid",
+  "phone",
+  "slug",
+  "username",
+  "ip",
+  "password",
+  "text",
+  "json",
+  "json.fast",
+  "json.secure",
+  "object",
+  "unknown",
+  "void",
+  "null",
+  "undefined",
+  "any",
+  "hexcolor",
+  "base64",
+  "jwt",
+  "semver",
+  "record",
+  "array", // only in additionalValidTypes
+] as const;
+
+export const VALIDATOR_TYPES = createEnum(SUPPORTED_VALIDATOR_TYPES);
+
+export const validatorTypeCategories = {
+  string: ["string"],
+  numeric: [
+    "number",
+    "float",
+    "int",
+    "integer",
+    "positive",
+    "negative",
+    "double",
+  ],
+  boolean: ["boolean", "bool"],
+  datetime: ["date", "datetime", "timestamp"],
+  validation: [
+    "email",
+    "uuid",
+    "guid",
+    "phone",
+    "slug",
+    "username",
+    "ip",
+    "password",
+  ],
+  content: ["text", "json", "json.fast", "json.secure", "object"],
+  special: ["unknown", "void", "null", "undefined", "any"],
+  extended: ["hexcolor", "base64", "jwt", "semver"],
+};
+
+export const BASE_TYPES = [
+  "string",
+  "number",
+  "boolean",
+  "date",
+  "uuid",
+  "email",
+  "url",
+  "phone",
+  "string[]",
+  "number[]",
+  "boolean[]",
+  "date[]",
+  "uuid[]",
+  "email[]",
+  "url[]",
+  "phone[]",
+];
+
+export const VALID_CONDITIONNAL_TYPES = BASE_TYPES.concat(UrlArgArray);

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

@@ -0,0 +1,109 @@
+
+/**
+ * Type definitions
+ */
+interface DocumentationOptions {
+    title?: string;
+    description?: string;
+    examples?: boolean;
+    interactive?: boolean;
+}
+
+interface OpenAPIOptions {
+    title: string;
+    version: string;
+    servers?: string[];
+}
+
+interface TypeScriptOptions {
+    exportName?: string;
+    namespace?: string;
+}
+
+interface InteractiveOptions {
+    title?: string;
+    theme?: "light" | "dark";
+    showExamples?: boolean;
+    allowTesting?: boolean;
+}
+
+interface Documentation {
+    markdown: string;
+    html: string;
+    openapi: OpenAPISpec;
+    json: any;
+    examples: any[];
+}
+
+interface InteractiveDocumentation {
+    html: string;
+    css: string;
+    javascript: string;
+}
+
+interface OpenAPISpec {
+    openapi: string;
+    info: {
+        title: string;
+        version: string;
+    };
+    servers?: Array<{ url: string }>;
+    components: {
+        schemas: Record<string, any>;
+    };
+}
+
+interface SchemaAnalysis {
+    fields: FieldInfo[];
+    totalFields: number;
+    requiredFields: number;
+    optionalFields: number;
+}
+
+interface FieldInfo {
+    name: string;
+    type: string;
+    required: boolean;
+    description: string;
+}
+
+
+export type {
+    DocumentationOptions,
+    OpenAPIOptions,
+    TypeScriptOptions,
+    InteractiveOptions,
+    Documentation,
+    InteractiveDocumentation,
+    OpenAPISpec,
+    SchemaAnalysis,
+    FieldInfo
+};
+
+
+
+
+/**
+ * Type definitions
+ */
+export interface ValidationResult {
+    isValid: boolean;
+    data: any;
+    errors: Record<string, string[]>;
+    timestamp: Date;
+}
+
+export interface FieldValidationResult {
+    field: string;
+    value: any;
+    isValid: boolean;
+    errors: string[];
+}
+
+export interface ValidationStats {
+    totalValidated: number;
+    validCount: number;
+    invalidCount: number;
+    errorRate: number;
+    startTime: Date;
+}

package/src/core/types/objValidationCache.ts

@@ -0,0 +1,17 @@
+import { SchemaValidationResult } from "./types";
+
+
+export interface CachedValidation {
+  result: SchemaValidationResult;
+  structureHash: string;
+  accessCount: number;
+  lastAccessed: number; 
+  validationTime: number;
+}
+
+export interface ValidationPath {
+  path: string[];
+  validator: (value: any) => SchemaValidationResult;
+  isHotPath: boolean;
+  avgValidationTime: number;
+}

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

@@ -0,0 +1,15 @@
+export interface ParsedConstraints {
+  type: string;
+  constraints: any;
+  optional: boolean;
+  required: boolean; // Non-empty/non-zero validation
+}
+
+export enum ConstraintType {
+  Min = "min",
+  Max = "max",
+  MinLength = "minLength",
+  MaxLength = "maxLength",
+  MinItems = "minItems",
+  MaxItems = "maxItems",
+}

package/src/core/types/perfoMonitor.ts

@@ -0,0 +1,37 @@
+
+export interface PerformanceMetric {
+  operationId: string;
+  duration: number;
+  timestamp: number;
+  schemaComplexity: number;
+  cacheHit: boolean;
+  optimizationApplied?: string;
+  memoryUsage?: number;
+}
+
+export interface OptimizationRecommendation {
+  type: 'cache' | 'precompile' | 'restructure' | 'hotpath' | 'memory';
+  priority: 'low' | 'medium' | 'high' | 'critical';
+  description: string;
+  estimatedImprovement: number; // percentage
+  implementation: () => Promise<void>;
+}
+
+export interface PerformanceProfile {
+  averageDuration: number;
+  p95Duration: number;
+  p99Duration: number;
+  throughput: number; // ops/sec
+  cacheHitRate: number;
+  memoryUsage: number;
+  bottlenecks: string[];
+  recommendations: OptimizationRecommendation[];
+}
+
+export interface PerformanceThresholds {
+  slowOperationMs: number;
+  criticalOperationMs: number;
+  minCacheHitRate: number;
+  maxMemoryMB: number;
+  autoOptimizeThreshold: number;
+}

package/src/core/types/scompiler.ts

@@ -0,0 +1,22 @@
+import { SchemaValidationResult } from "./types";
+
+export interface CompiledValidator {
+  validate: (value: any) => SchemaValidationResult;
+  metadata: {
+    complexity: number;
+    fieldCount: number;
+    nestingLevel: number;
+    hasUnions: boolean;
+    hasArrays: boolean;
+    hasConditionals: boolean;
+  };
+  cacheKey: string;
+  compiledAt: number;
+}
+
+export interface OptimizationStrategy {
+  name: string;
+  condition: (metadata: CompiledValidator['metadata']) => boolean;
+  optimize: (validator: CompiledValidator) => CompiledValidator;
+}
+

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

@@ -0,0 +1,10 @@
+export interface ValidationTimeout {
+  timeoutMs: number;
+}
+
+export interface SecurityValidationOptions {
+  timeout?: number;
+  enableMetrics?: boolean;
+  customPatterns?: RegExp[];
+  bypassCache?: boolean;
+}

package/src/core/types/types.ts

@@ -0,0 +1,154 @@
+/**
+ * Core types and interfaces for the FortifyJS Schema system
+ */
+
+/**
+ * Rich validation error with detailed information
+ */
+export interface ValidationError {
+  /** Field path where the error occurred (e.g., ['user', 'profile', 'email']) */
+  path: string[];
+  /** Human-readable error message */
+  message: string;
+  /** Error code for programmatic handling */
+  code: string;
+  /** Expected value or type */
+  expected: string;
+  /** Actual received value */
+  received: any; 
+  /** Type of the received value */
+  receivedType: string;
+  /** Additional context or suggestions */
+  context?: {
+    suggestion?: string;
+    allowedValues?: any[];
+    constraints?: Record<string, any>;
+  };
+}
+
+/**
+ * Schema validation result with rich error information
+ */
+export interface SchemaValidationResult<T = any> {
+  success: boolean;
+  data?: T;
+  errors: ValidationError[];
+  warnings: string[];
+}
+
+/**
+ * Base schema configuration options
+ */
+export interface BaseSchemaOptions {
+  optional?: boolean;
+  nullable?: boolean;
+  default?: any;
+}
+
+/**
+ * String schema validation options
+ */
+export interface StringSchemaOptions extends BaseSchemaOptions {
+  minLength?: number;
+  maxLength?: number;
+  pattern?: RegExp;
+  format?: "email" | "url" | "uuid" | "phone" | "slug" | "username";
+}
+
+/**
+ * Number schema validation options
+ */
+export interface NumberSchemaOptions extends BaseSchemaOptions {
+  min?: number;
+  max?: number;
+  integer?: boolean;
+  positive?: boolean;
+  precision?: number;
+}
+
+/**
+ * Boolean schema validation options
+ */
+export interface BooleanSchemaOptions extends BaseSchemaOptions {
+  strict?: boolean; // Only accept true boolean values
+}
+
+/**
+ * Array schema validation options
+ */
+export interface ArraySchemaOptions extends BaseSchemaOptions {
+  minLength?: number;
+  maxLength?: number;
+  unique?: boolean;
+}
+
+/**
+ * Object schema validation options
+ */
+export interface ObjectSchemaOptions extends BaseSchemaOptions {
+  strict?: boolean; // No extra properties allowed
+  allowUnknown?: boolean; // Allow unknown properties
+}
+
+/**
+ * Schema type definitions
+ */
+export type SchemaType =
+  | "string"
+  | "number"
+  | "boolean"
+  | "array"
+  | "object"
+  | "date"
+  | "any";
+
+/**
+ * Schema definition for object properties
+ */
+export type SchemaDefinition = {
+  [key: string]: SchemaConfig;
+};
+
+/**
+ * Complete schema configuration
+ */
+export interface SchemaConfig {
+  type: SchemaType;
+  options?: BaseSchemaOptions;
+  elementSchema?: SchemaConfig; // For arrays
+  properties?: SchemaDefinition; // For objects
+  validator?: (value: any) => void; // Custom validator function
+}
+
+// interfaces
+
+/**
+ * Internal conditional pattern interface
+ */
+export interface ConditionalPattern {
+  field: string;
+  operator:
+    | "="
+    | "!="
+    | ">"
+    | "<"
+    | ">="
+    | "<="
+    | "~"
+    | "!~"
+    | "in"
+    | "!in"
+    | "exists"
+    | "!exists"
+    | "empty"
+    | "!empty"
+    | "null"
+    | "!null"
+    | "startsWith"
+    | "endsWith"
+    | "contains"
+    | "!contains";
+  value?: any;
+  thenSchema: string;
+  elseSchema?: string;
+}