reliant-type 1.0.0 → 2.1.4

package/dist/esm/index.js

@@ -1,7 +1,8 @@
 export { FieldTypes, Interface, QuickSchemas } from './core/schema/mode/interfaces/Interface.js';
 export { Extensions, Quick } from './core/schema/extensions/index.js';
-export { InterfaceSchema } from './core/schema/mode/interfaces/InterfaceSchema.js';
+import { InterfaceSchema } from './core/schema/mode/interfaces/InterfaceSchema.js';
 export { PerformanceMonitor } from './core/schema/optimization/PerformanceMonitor.js';
+import { TypeScriptGenerator } from './core/schema/extensions/mods/typescript-generator.js';
 export { Make } from './core/utils/Make.js';
 export { Mod } from './core/utils/Mod.js';
 export { Smart } from './core/schema/extensions/SmartInference.js';
@@ -9,4 +10,80 @@ export { When } from './core/schema/extensions/components/ConditionalValidation/
 export { Live } from './core/schema/extensions/components/RealtimeValidation/index.js';
 export { Docs } from './core/schema/extensions/components/AutoDocumentation/Docs.js';
 export { TypeScriptGenerator } from './core/schema/extensions/components/AutoDocumentation/TypeScriptGenerator.js';
+
+/***************************************************************************
+ *  ReliantType - TypeScript Interface-like Schema Validation
+ *
+ * @file index.ts
+ *
+ * @author Nehonix
+ * @license MIT
+ *
+ * Copyright (c) 2025 Nehonix Team. All rights reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ *
+ ****************************************************************************/
+/**
+ * ReliantType - TypeScript Interface-like Schema Validation
+ *
+ * A schema validation system with TypeScript interface-like syntax
+ * that's incredibly easy to use and much safer than traditional schema libraries.
+ *
+ * @example Interface-based (Recommended)
+ * ```typescript
+ * import { Interface, Make, Mod } from 'reliant-type';
+ *
+ * const UserSchema = Interface({
+ *   id: "number",
+ *   email: "email",
+ *   name: "string",
+ *   age: "number?",                        // Optional
+ *   status: Make.union("active", "inactive"),
+ *   role: Make.const("user")      // Safe constant
+ * });
+ *
+ * // Transform schemas easily
+ * const PublicUserSchema = Mod.omit(UserSchema, ["password"]);
+ * const PartialUserSchema = Mod.partial(UserSchema);
+ *
+ * const result = UserSchema.safeParse(userData);
+ * ```
+ *
+ * @example Traditional Fluent API
+ * ```typescript
+ * import { Schema } from 'reliant-type';
+ *
+ * const UserSchema = Schema.object({
+ *   id: Schema.number().int().positive(),
+ *   email: Schema.string().email(),
+ *   name: Schema.string().min(2).max(50)
+ * });
+ * ```
+ */
+// Main Interface-based API
+// Register the TypeScript generator for InterfaceSchema to enable .types property
+InterfaceSchema.tsGenerator = (definition, options) => {
+    return TypeScriptGenerator.generateInterface(definition, {
+        exportName: options?.name || "Schema"
+    });
+};
+
+export { InterfaceSchema };
 //# sourceMappingURL=index.js.map

package/dist/esm/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;"}
+{"version":3,"file":"index.js","sources":["../../src/index.ts"],"sourcesContent":[null],"names":["TSGenerator"],"mappings":";;;;;;;;;;;;;AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA4B8E;AAE9E;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAoCG;AAEH;AA2DA;AACA,eAAe,CAAC,WAAW,GAAG,CAAC,UAAU,EAAE,OAAO,KAAI;AACpD,IAAA,OAAOA,mBAAW,CAAC,iBAAiB,CAAC,UAAU,EAAE;AAC/C,QAAA,UAAU,EAAE,OAAO,EAAE,IAAI,IAAI,QAAQ;AACtC,KAAA,CAAC,CAAC;AACL,CAAC;;;;"}

package/dist/schema.d.ts

@@ -160,6 +160,8 @@ interface SchemaOptions {
     enableOptimizations?: boolean;
     cacheValidation?: boolean;
     skipOptimization?: boolean;
+    name?: string;
+    description?: string;
 }
 type AllowUnknownSchema<T> = T & Record<string, any>;
 
@@ -184,6 +186,28 @@ declare class InterfaceSchema<T = any> {
     private isOptimized;
     private precompiledValidator?;
     private optimizationLevel;
+    /**
+     * Static generator for TypeScript types
+     * This is set by the extension system to avoid circular dependencies
+     */
+    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;
+    /**
+     * Alias for types property to support different coding styles
+     */
+    getTypes(): T;
     constructor(definition: SchemaInterface, options?: SchemaOptions);
     /**
      * Check if a field type uses conditional syntax using secure regex pattern
@@ -361,14 +385,15 @@ type CoreTypeMap = {
     float: number;
     double: number;
     unknown: unknown;
-    void: undefined;
+    void: void;
     null: null;
     undefined: undefined;
+    TYPE: any;
 };
 /**
  * Extract base type from field type string (removes constraints and modifiers)
  */
-type ExtractBaseType<T extends string> = T extends `${infer Base}(${string})` ? Base : T extends `${infer Base}?` ? Base : T extends `${infer Base}[]` ? Base : T extends `${infer Base}[]?` ? Base : T extends `${infer Base}!` ? Base : T extends `(${infer Content})?` ? Content : T extends `(${infer Content})` ? Content : T;
+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 : T extends `${infer Base}[]` ? Base : T extends `${infer Base}[]?` ? Base : T extends `${infer Base}!` ? Base : T extends `(${infer Content})?` ? Content : T extends `(${infer Content})` ? Content : T;
 /**
  * Check if field type is optional
  */
@@ -384,7 +409,7 @@ type ExtractElementType<T extends string> = T extends `${infer Element}[]` ? Ele
 /**
  * Map field type string to TypeScript type
  */
-type MapFieldType<T extends string> = IsArray<T> extends true ? Array<MapFieldType<ExtractElementType<T>>> : T extends `record<${infer K}, ${infer V}>` ? Record<MapFieldType<K> extends string | number | symbol ? MapFieldType<K> : string, MapFieldType<V>> : T extends `Record<${infer K}, ${infer V}>` ? Record<MapFieldType<K> extends string | number | symbol ? MapFieldType<K> : string, MapFieldType<V>> : T extends `when ${string} *? ${string}` ? InferConditionalType<T> : ExtractBaseType<T> extends `${string}|${string}` ? ParseUnionType<ExtractBaseType<T>> : T extends `=${infer Value}?` ? Value | undefined : T extends `=${infer Value}` ? Value : ExtractBaseType<T> extends keyof CoreTypeMap ? CoreTypeMap[ExtractBaseType<T>] : any;
+type MapFieldType<T extends string> = IsArray<T> extends true ? Array<MapFieldType<ExtractElementType<T>>> : T extends `record<${infer K}, ${infer V}>` ? Record<MapFieldType<K> extends string | number | symbol ? MapFieldType<K> : string, MapFieldType<V>> : T extends `Record<${infer K}, ${infer V}>` ? Record<MapFieldType<K> extends string | number | symbol ? MapFieldType<K> : string, MapFieldType<V>> : T extends `when ${string} *? ${string}` ? InferConditionalType<T> : ExtractBaseType<T> extends `fn(${infer Sig})` ? ParseFunctionType<Sig> : ExtractBaseType<T> extends `${string}|${string}` ? ParseUnionType<ExtractBaseType<T>> : T extends `=${infer Value}?` ? Value | undefined : T extends `=${infer Value}` ? Value : ExtractBaseType<T> extends keyof CoreTypeMap ? CoreTypeMap[ExtractBaseType<T>] : any;
 /**
  * Utility type to trim whitespace from string literal types
  */
@@ -393,6 +418,22 @@ type Trim<T extends string> = T extends ` ${infer Rest}` ? Trim<Rest> : T extend
  * Parse union type string into union of literal types
  */
 type ParseUnionType<T extends string> = T extends `(${infer Content})` ? ParseUnionType<Trim<Content>> : T extends `${infer First}|${infer Rest}` ? Trim<First> | ParseUnionType<Rest> : Trim<T>;
+/**
+ * Parse function signature string into a real TypeScript function type
+ */
+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
+ */
+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
+ */
+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)
+ */
+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/docs/FUNCTION-TYPES.md

@@ -0,0 +1,120 @@
+# Function Types
+
+ReliantType introduces powerful runtime and compile-time validation for function signatures using the `fn` type. This feature allows you to define strict contracts for functions within your schema, ensuring that both arguments and return values adhere to specified types during execution.
+
+## Overview
+
+The `fn` type enables you to describe function signatures using a syntax similar to TypeScript arrow functions. These definitions are used to:
+
+1.  **Validate at Runtime**: Wraps the function to strictly enforce argument types, argument count, and return types every time the function is called.
+2.  **Infer TypeScript Types**: Automatically generates accurate TypeScript definitions for your IDE, including argument names, types, and return values.
+
+## Syntax
+
+The general syntax follows the pattern:
+
+```typescript
+"fn((argument_list) => return_type)";
+```
+
+### Components
+
+- **`fn(...)`**: The wrapper indicating a function type.
+- **`argument_list`**: A comma-separated list of arguments in the format `name: type`.
+- **`return_type`**: The expected return type of the function.
+
+## Features
+
+### 1. Basic Function Signatures
+
+Define functions with specific argument types and return types.
+
+```typescript
+const schema = Interface({
+  // Function taking a string and returning a boolean
+  isValid: "fn((input: string) => boolean)",
+
+  // Function taking two numbers and returning a number
+  add: "fn((a: number, b: number) => number)",
+});
+```
+
+### 2. Optional Arguments
+
+Mark arguments as optional using the `?` suffix on the argument name or type.
+
+```typescript
+const schema = Interface({
+  // 'context' is optional
+  log: "fn((message: string, context?: object) => void)",
+});
+```
+
+### 3. Rest Parameters (Spread Operator)
+
+Support for variadic functions using the spread operator (`...`). This is fully supported in both runtime validation and TypeScript inference.
+
+```typescript
+const schema = Interface({
+  // Accepts any number of numeric arguments
+  sum: "fn((...numbers: number[]) => number)",
+});
+```
+
+### 4. The `TYPE` Placeholder
+
+Use `TYPE` as a placeholder for `any`. This is useful when you want to enforce the presence of an argument or a return value without strictly validating its content, or when the type is too complex to describe in a string.
+
+```typescript
+const schema = Interface({
+  // Accepts a generic input and returns a generic output
+  transform: "fn((input: TYPE) => TYPE)",
+});
+```
+
+### 5. Void Return Type
+
+Use `void` to indicate that the function should not return a value (or that the return value should be ignored).
+
+```typescript
+const schema = Interface({
+  callback: "fn(() => void)",
+});
+```
+
+## Runtime Validation Behavior
+
+ReliantType enforces a **Strict Contract** policy for functions. When a function defined in a schema is accessed, it is wrapped in a validation proxy.
+
+- **Argument Count**: Throws an error if required arguments are missing.
+- **Argument Types**: Throws an error if an argument does not match its defined type.
+- **Return Type**: Throws an error if the function returns a value that does not match the defined return type.
+
+### Example of Validation Failure
+
+```typescript
+const config = {
+  // Incorrect implementation: returns a string instead of a number
+  calculator: (a, b) => "result",
+};
+
+const schema = Interface({
+  calculator: "fn((a: number, b: number) => number)",
+});
+
+const result = schema.parse(config);
+
+// This call will THROW an Error:
+// "[ReliantType] Return value validation failed... Expected number, got string"
+result.calculator(10, 20);
+```
+
+## TypeScript Integration
+
+The `fn` syntax is fully compatible with ReliantType's type inference system.
+
+- `fn((a: string) => number)` infers to `(a: string) => number`
+- `fn((...args: string[]) => void)` infers to `(...args: string[]) => void`
+- `fn((opt?: string) => boolean)` infers to `(opt?: string | undefined) => boolean`
+
+This ensures that your IDE provides correct autocompletion and type checking for implementation code.

package/docs/GETTING-STARTED.md

@@ -1,10 +1,11 @@
 # Getting Started with ReliantType
 
 Welcome to ReliantType! This guide will get you up and running in minutes with TypeScript-first validation using interface-native syntax.
- 
+
 ## 🚀 Installation
 
 ### Requirements
+
 - **TypeScript 4.5+** or **JavaScript ES2020+**
 - **Node.js 14+** (for Node.js projects)
 - **Modern browser** (for browser projects)
@@ -31,7 +32,7 @@ For the best development experience, install our VS Code extension:
 
 ```bash
 # Download and install
-curl -L https://sdk.nehonix.space/pkgs/mods/vscode/latest/reliant-type.vsix -o reliant-type.vsix
+curl -L https://dll.nehonix.com/pkgs/mods/vscode/latest/reliant-type.vsix -o reliant-type.vsix
 code --install-extension reliant-type.vsix
 ```
 
@@ -52,8 +53,8 @@ const UserSchema = Interface({
   id: "number",
   email: "email",
   name: "string",
-  age: "number?",        // Optional field
-  isActive: "boolean"
+  age: "number?", // Optional field
+  isActive: "boolean",
 });
 ```
 
@@ -66,7 +67,7 @@ const userData = {
   email: "john@example.com",
   name: "John Doe",
   age: 30,
-  isActive: true
+  isActive: true,
 };
 
 // Validate with safeParse (recommended)
@@ -91,13 +92,13 @@ ReliantType uses familiar TypeScript interface syntax:
 ```typescript
 // Looks like a TypeScript interface!
 const ProductSchema = Interface({
-  id: "uuid",                    // UUID validation
-  name: "string(1,100)",         // String with length constraints
+  id: "uuid", // UUID validation
+  name: "string(1,100)", // String with length constraints
   price: "number(0.01,9999.99)", // Number with range constraints
   category: "electronics|books|clothing", // Union types
   inStock: "boolean",
-  tags: "string[]?",             // Optional array
-  createdAt: "date"              // Date validation
+  tags: "string[]?", // Optional array
+  createdAt: "date", // Date validation
 });
 ```
 
@@ -149,17 +150,17 @@ const BasicSchema = Interface({
   age: "number",
   active: "boolean",
   birthday: "date",
-  
+
   // Optional types (add ?)
   nickname: "string?",
   bio: "string?",
-  
+
   // Arrays
   tags: "string[]",
   scores: "number[]?",
-  
+
   // Any type (use sparingly)
-  metadata: "any"
+  metadata: "any",
 });
 ```
 
@@ -168,18 +169,18 @@ const BasicSchema = Interface({
 ```typescript
 const ConstrainedSchema = Interface({
   // String constraints
-  username: "string(3,20)",      // 3-20 characters
-  password: "string(8,)",        // Minimum 8 characters
-  code: "string(6,6)",           // Exactly 6 characters
-  
+  username: "string(3,20)", // 3-20 characters
+  password: "string(8,)", // Minimum 8 characters
+  code: "string(6,6)", // Exactly 6 characters
+
   // Number constraints
-  age: "number(0,120)",          // Range 0-120
-  price: "number(0.01,)",        // Minimum 0.01
-  discount: "number(,0.5)",      // Maximum 0.5
-  
+  age: "number(0,120)", // Range 0-120
+  price: "number(0.01,)", // Minimum 0.01
+  discount: "number(,0.5)", // Maximum 0.5
+
   // Array constraints
-  tags: "string[](1,5)",         // 1-5 items
-  scores: "number[](,10)"        // Maximum 10 items
+  tags: "string[](1,5)", // 1-5 items
+  scores: "number[](,10)", // Maximum 10 items
 });
 ```
 
@@ -191,10 +192,10 @@ const FormatSchema = Interface({
   website: "url",
   phone: "phone",
   userId: "uuid",
-  
+
   // Custom regex patterns
   zipCode: "string(/^\\d{5}(-\\d{4})?$/)",
-  productCode: "string(/^[A-Z]{2}\\d{4}$/)"
+  productCode: "string(/^[A-Z]{2}\\d{4}$/)",
 });
 ```
 
@@ -205,10 +206,10 @@ const UnionSchema = Interface({
   status: "active|inactive|pending",
   role: "admin|user|guest|moderator",
   theme: "light|dark|auto",
-  
+
   // Mixed type unions
   id: "string|number",
-  value: "string|number|boolean"
+  value: "string|number|boolean",
 });
 ```
 
@@ -222,11 +223,11 @@ ReliantType V2 introduces powerful conditional validation with runtime property
 const ConditionalSchema = Interface({
   role: "admin|user|guest",
   config: "any?",
-  
+
   // V2 Runtime Methods
   hasPermissions: "when config.permissions.$exists() *? boolean : =false",
   isAdmin: "when role=admin *? boolean : =false",
-  canEdit: "when role.$in(admin,moderator) *? boolean : =false"
+  canEdit: "when role.$in(admin,moderator) *? boolean : =false",
 });
 ```
 
@@ -235,26 +236,28 @@ const ConditionalSchema = Interface({
 ```typescript
 const V2MethodsSchema = Interface({
   data: "any?",
-  
+
   // Property existence
   hasData: "when data.field.$exists() *? boolean : =false",
-  
+
   // Empty checking
   isEmpty: "when data.list.$empty() *? boolean : =true",
-  
+
   // Null checking
   isNull: "when data.value.$null() *? boolean : =false",
-  
+
   // String methods
-  containsText: "when data.description.$contains(important) *? boolean : =false",
+  containsText:
+    "when data.description.$contains(important) *? boolean : =false",
   startsWithPrefix: "when data.code.$startsWith(PRE) *? boolean : =false",
   endsWithSuffix: "when data.filename.$endsWith(.pdf) *? boolean : =false",
-  
+
   // Numeric range
   inRange: "when data.score.$between(0,100) *? boolean : =false",
-  
+
   // Value inclusion
-  isValidStatus: "when data.status.$in(active,pending,inactive) *? boolean : =false"
+  isValidStatus:
+    "when data.status.$in(active,pending,inactive) *? boolean : =false",
 });
 ```
 
@@ -270,15 +273,15 @@ const UserRegistrationSchema = Interface({
   email: "email",
   password: "string(8,128)",
   confirmPassword: "string(8,128)",
-  
+
   // Profile
   profile: {
     firstName: "string(1,50)",
     lastName: "string(1,50)",
     dateOfBirth: "date?",
-    avatar: "url?"
+    avatar: "url?",
   },
-  
+
   // Preferences
   preferences: {
     theme: "light|dark|auto",
@@ -286,23 +289,23 @@ const UserRegistrationSchema = Interface({
     notifications: {
       email: "boolean",
       push: "boolean",
-      sms: "boolean"
-    }
+      sms: "boolean",
+    },
   },
-  
+
   // Terms and conditions
   acceptedTerms: "boolean",
   acceptedPrivacy: "boolean",
-  
+
   // Optional marketing consent
   marketingConsent: "boolean?",
-  
+
   // Runtime configuration for conditional validation
   config: "any?",
-  
+
   // Conditional fields based on configuration
   betaFeatures: "when config.beta.$exists() *? string[] : =[]",
-  premiumFeatures: "when config.premium.$exists() *? any : =null"
+  premiumFeatures: "when config.premium.$exists() *? any : =null",
 });
 
 // Usage
@@ -313,7 +316,7 @@ const registrationData = {
   profile: {
     firstName: "John",
     lastName: "Doe",
-    dateOfBirth: new Date("1990-01-01")
+    dateOfBirth: new Date("1990-01-01"),
   },
   preferences: {
     theme: "dark",
@@ -321,12 +324,12 @@ const registrationData = {
     notifications: {
       email: true,
       push: false,
-      sms: false
-    }
+      sms: false,
+    },
   },
   acceptedTerms: true,
   acceptedPrivacy: true,
-  marketingConsent: false
+  marketingConsent: false,
 };
 
 const result = UserRegistrationSchema.safeParse(registrationData);
@@ -336,8 +339,8 @@ if (result.success) {
   // Process registration with result.data
 } else {
   console.log("❌ Validation errors:");
-  result.errors.forEach(error => {
-    console.log(`- ${error.path.join('.')}: ${error.message}`);
+  result.errors.forEach((error) => {
+    console.log(`- ${error.path.join(".")}: ${error.message}`);
   });
 }
 ```