reliant-type 1.0.0

package/src/core/schema/extensions/components/AutoDocumentation/OpenAPIGenerator.ts

@@ -0,0 +1,175 @@
+import { OpenAPIOptions, OpenAPISpec } from "../../../../types/extension.type";
+import { SchemaInterface } from "../../../../types/SchemaValidator.type";
+
+/**
+ * OpenAPI generator
+ */
+export class OpenAPIGenerator {
+    constructor(
+        private schema: SchemaInterface,
+        private options: OpenAPIOptions
+    ) {}
+
+    generate(): OpenAPISpec {
+        return {
+            openapi: "3.0.0",
+            info: {
+                title: this.options.title,
+                version: this.options.version
+            },
+            servers: this.options.servers?.map(url => ({ url })) || [],
+            components: {
+                schemas: {
+                    [this.options.title]: this.convertSchema()
+                }
+            }
+        };
+    }
+
+    private convertSchema(): any {
+        const properties: any = {};
+        const required: string[] = [];
+
+        Object.entries(this.schema).forEach(([fieldName, fieldType]) => {
+            const openApiProperty = this.convertFieldToOpenAPIProperty(fieldName, fieldType);
+            properties[fieldName] = openApiProperty.schema;
+
+            if (openApiProperty.required) {
+                required.push(fieldName);
+            }
+        });
+
+        return {
+            type: "object",
+            properties,
+            required: required.length > 0 ? required : undefined
+        };
+    }
+
+    private convertFieldToOpenAPIProperty(_fieldName: string, fieldType: any): { schema: any; required: boolean } {
+        if (typeof fieldType === "string") {
+            const isOptional = fieldType.includes("?");
+            const cleanType = fieldType.replace("?", "");
+
+            // Handle string types with constraints
+            if (cleanType.startsWith("string")) {
+                const constraints = this.parseStringConstraints(cleanType);
+                return {
+                    schema: {
+                        type: "string",
+                        ...constraints
+                    },
+                    required: !isOptional
+                };
+            }
+
+            // Handle specific string formats
+            if (cleanType === "email") {
+                return {
+                    schema: { type: "string", format: "email" },
+                    required: !isOptional
+                };
+            }
+
+            if (cleanType === "url") {
+                return {
+                    schema: { type: "string", format: "uri" },
+                    required: !isOptional
+                };
+            }
+
+            if (cleanType === "uuid") {
+                return {
+                    schema: { type: "string", format: "uuid" },
+                    required: !isOptional
+                };
+            }
+
+            if (cleanType === "date") {
+                return {
+                    schema: { type: "string", format: "date-time" },
+                    required: !isOptional
+                };
+            }
+
+            // Handle number types
+            if (cleanType === "number" || cleanType === "positive" || cleanType === "int") {
+                const schema: any = { type: cleanType === "int" ? "integer" : "number" };
+                if (cleanType === "positive") {
+                    schema.minimum = 0;
+                    schema.exclusiveMinimum = true;
+                }
+                return { schema, required: !isOptional };
+            }
+
+            // Handle boolean
+            if (cleanType === "boolean") {
+                return {
+                    schema: { type: "boolean" },
+                    required: !isOptional
+                };
+            }
+
+            // Handle arrays
+            if (cleanType.includes("[]")) {
+                const itemType = cleanType.replace("[]", "");
+                const itemSchema = this.convertFieldToOpenAPIProperty("item", itemType).schema;
+                return {
+                    schema: {
+                        type: "array",
+                        items: itemSchema
+                    },
+                    required: !isOptional
+                };
+            }
+
+            // Default to string
+            return {
+                schema: { type: "string" },
+                required: !isOptional
+            };
+        }
+
+        // Handle object types
+        if (typeof fieldType === "object" && !Array.isArray(fieldType)) {
+            const nestedProperties: any = {};
+            const nestedRequired: string[] = [];
+
+            Object.entries(fieldType).forEach(([nestedField, nestedType]) => {
+                const nestedProperty = this.convertFieldToOpenAPIProperty(nestedField, nestedType);
+                nestedProperties[nestedField] = nestedProperty.schema;
+                if (nestedProperty.required) {
+                    nestedRequired.push(nestedField);
+                }
+            });
+
+            return {
+                schema: {
+                    type: "object",
+                    properties: nestedProperties,
+                    required: nestedRequired.length > 0 ? nestedRequired : undefined
+                },
+                required: true
+            };
+        }
+
+        // Fallback
+        return {
+            schema: { type: "string" },
+            required: true
+        };
+    }
+
+    private parseStringConstraints(stringType: string): any {
+        const constraints: any = {};
+
+        // Parse string(min,max) format
+        const match = stringType.match(/string\((\d+)?,?(\d+)?\)/);
+        if (match) {
+            if (match[1]) constraints.minLength = parseInt(match[1]);
+            if (match[2]) constraints.maxLength = parseInt(match[2]);
+        }
+
+        return constraints;
+    }
+}

package/src/core/schema/extensions/components/AutoDocumentation/SchemaAnalyzer.ts

@@ -0,0 +1,49 @@
+import { FieldInfo, SchemaAnalysis } from "../../../../types/extension.type";
+import { SchemaInterface } from "../../../../types/SchemaValidator.type";
+
+/**
+ * Schema analyzer for extracting field information
+ */
+export class SchemaAnalyzer {
+    constructor(private schema: SchemaInterface) {}
+
+    analyze(): SchemaAnalysis {
+        const fields: FieldInfo[] = [];
+
+        Object.entries(this.schema).forEach(([name, type]) => {
+            fields.push(this.analyzeField(name, type));
+        });
+
+        return {
+            fields,
+            totalFields: fields.length,
+            requiredFields: fields.filter(f => f.required).length,
+            optionalFields: fields.filter(f => !f.required).length
+        };
+    }
+
+    private analyzeField(name: string, type: any): FieldInfo {
+        const typeStr = typeof type === "string" ? type : JSON.stringify(type);
+        const required = !typeStr.includes("?");
+
+        return {
+            name,
+            type: typeStr,
+            required,
+            description: this.generateFieldDescription(name, typeStr)
+        };
+    }
+
+    private generateFieldDescription(name: string, type: string): string {
+        if (type === "email") return "Email address";
+        if (type === "uuid") return "Unique identifier";
+        if (type === "url") return "URL address";
+        if (type.includes("string")) return "Text value";
+        if (type.includes("number")) return "Numeric value";
+        if (type === "boolean") return "True/false value";
+        if (type === "date") return "Date and time";
+        if (type.includes("[]")) return "Array of values";
+
+        return `${name} field`;
+    }
+}

package/src/core/schema/extensions/components/AutoDocumentation/TypeScriptGenerator.ts

@@ -0,0 +1,54 @@
+import { SchemaInterface } from "../../../../types/SchemaValidator.type";
+import { TypeScriptOptions } from "../../mods";
+
+/**
+ * TypeScript generator
+ */
+export class TypeScriptGenerator {
+    constructor(
+        private schema: SchemaInterface,
+        private options: TypeScriptOptions
+    ) {}
+
+    generate(): string {
+        const { exportName = "Schema", namespace } = this.options;
+
+        let output = "";
+
+        if (namespace) {
+            output += `export namespace ${namespace} {\n`;
+        }
+
+        output += `export interface ${exportName} {\n`;
+
+        Object.entries(this.schema).forEach(([name, type]) => {
+            const tsType = this.convertToTypeScript(type);
+            const optional = typeof type === "string" && type.includes("?") ? "?" : "";
+            output += `  ${name}${optional}: ${tsType};\n`;
+        });
+
+        output += "}\n";
+
+        if (namespace) {
+            output += "}\n";
+        }
+
+        return output;
+    }
+
+    private convertToTypeScript(type: any): string {
+        if (typeof type === "string") {
+            const cleanType = type.replace("?", "");
+
+            if (cleanType === "email" || cleanType === "uuid" || cleanType === "url") return "string";
+            if (cleanType.startsWith("string")) return "string";
+            if (cleanType.includes("number") || cleanType === "positive" || cleanType === "int") return "number";
+            if (cleanType === "boolean") return "boolean";
+            if (cleanType === "date") return "Date";
+            if (cleanType.includes("[]")) return `${this.convertToTypeScript(cleanType.replace("[]", ""))}[]`;
+        }
+
+        return "any";
+    }
+}
+

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

@@ -0,0 +1,17 @@
+/**
+ * Auto Documentation - schema documentation generator
+ *
+ * This module automatically generates beautiful documentation from schemas,
+ * including API docs, type definitions, and interactive examples.
+ *
+ */
+import { Docs } from "./Docs";
+
+export { DocumentationGenerator } from "./DocumentationGenerator";
+export { SchemaAnalyzer } from "./SchemaAnalyzer";
+export { TypeScriptGenerator } from "./TypeScriptGenerator";
+export { OpenAPIGenerator } from "./OpenAPIGenerator";
+export { InteractiveDocumentationGenerator } from "./InteractiveDocumentationGenerator";
+export { Docs } from "./Docs";
+
+export default Docs;

package/src/core/schema/extensions/components/ConditionalValidation/ConditionalBuilder.ts

@@ -0,0 +1,101 @@
+import { ConditionalThen } from "./ConditionalThen";
+
+// Type helper to infer field types from schema strings
+type InferFieldType<T extends string> =
+    T extends "string" ? string :
+    T extends "string?" ? string | undefined :
+    T extends "number" ? number :
+    T extends "number?" ? number | undefined :
+    T extends "boolean" ? boolean :
+    T extends "boolean?" ? boolean | undefined :
+    T extends "string[]" ? string[] :
+    T extends "string[]?" ? string[] | undefined :
+    T extends "number[]" ? number[] :
+    T extends "number[]?" ? number[] | undefined :
+    T extends "boolean[]" ? boolean[] :
+    T extends "boolean[]?" ? boolean[] | undefined :
+    T extends `${string}|${string}` ? string :
+    any;
+
+// Type-safe conditional builder result
+type ConditionalBuilderResult<TThen extends string, TElse extends string = never> =
+    TElse extends never
+        ? { __conditional: true; __inferredType: InferFieldType<TThen> }
+        : { __conditional: true; __inferredType: InferFieldType<TThen> | InferFieldType<TElse> };
+
+/**
+ * Builder for single field conditional validation with TypeScript inference
+ */
+export class ConditionalBuilder {
+    private conditions: Array<{
+        condition: (value: any) => boolean;
+        schema: any;
+    }> = [];
+    private defaultSchema: any = null;
+
+    constructor(private fieldName: string) {}
+
+    /**
+     * Check if field equals specific value
+     */
+    is(value: any): ConditionalThen {
+        return new ConditionalThen(this, (fieldValue) => fieldValue === value);
+    }
+
+    /**
+     * Check if field does not equal specific value
+     */
+    isNot(value: any): ConditionalThen {
+        return new ConditionalThen(this, (fieldValue) => fieldValue !== value);
+    }
+
+    /**
+     * Check if field exists (not null/undefined)
+     */
+    exists(): ConditionalThen {
+        return new ConditionalThen(this, (fieldValue) => fieldValue != null);
+    }
+
+    /**
+     * Check if field matches pattern
+     */
+    matches(pattern: RegExp): ConditionalThen {
+        return new ConditionalThen(this, (fieldValue) =>
+            typeof fieldValue === "string" && pattern.test(fieldValue)
+        );
+    }
+
+    /**
+     * Check if field is in array of values
+     */
+    in(values: any[]): ConditionalThen {
+        return new ConditionalThen(this, (fieldValue) => values.includes(fieldValue));
+    }
+
+    /**
+     * Custom condition function
+     */
+    when(condition: (value: any) => boolean): ConditionalThen {
+        return new ConditionalThen(this, condition);
+    }
+
+    addCondition(condition: (value: any) => boolean, schema: any): this {
+        this.conditions.push({ condition, schema });
+        return this;
+    }
+
+    default(schema: any): any {
+        this.defaultSchema = schema;
+        return this.build();
+    }
+
+    build(): any {
+        // Return a special object that the validation engine can recognize
+        return {
+            __conditional: true,
+            fieldName: this.fieldName,
+            conditions: this.conditions,
+            default: this.defaultSchema
+        };
+    }
+}

package/src/core/schema/extensions/components/ConditionalValidation/ConditionalElse.ts

@@ -0,0 +1,65 @@
+import { ConditionalBuilder } from "./ConditionalBuilder";
+
+// Type helper to infer field types from schema strings
+type InferFieldType<T extends string> =
+    T extends "string" ? string :
+    T extends "string?" ? string | undefined :
+    T extends "number" ? number :
+    T extends "number?" ? number | undefined :
+    T extends "boolean" ? boolean :
+    T extends "boolean?" ? boolean | undefined :
+    T extends "string[]" ? string[] :
+    T extends "string[]?" ? string[] | undefined :
+    T extends "number[]" ? number[] :
+    T extends "number[]?" ? number[] | undefined :
+    T extends "boolean[]" ? boolean[] :
+    T extends "boolean[]?" ? boolean[] | undefined :
+    T extends `${string}|${string}` ? string :
+    any;
+
+// Type-safe conditional result with proper inference
+type ConditionalResult<TThen extends string, TElse extends string> = {
+    __conditional: true;
+    __inferredType: InferFieldType<TThen> | InferFieldType<TElse>;
+};
+
+/**
+ * Builder for the "else" part of conditional validation with TypeScript inference
+ * This class is returned after calling .then() and provides the .else() method
+ */
+export class ConditionalElse<TThen extends string = string> {
+    constructor(
+        private builder: ConditionalBuilder,
+        private condition: (value: any) => boolean,
+        private thenSchema: TThen
+    ) {}
+
+    /**
+     * Specify the schema to use when the condition is false
+     */
+    else<TElse extends string>(elseSchema: TElse): ConditionalResult<TThen, TElse> {
+        // Add the condition with the "then" schema
+        this.builder.addCondition(this.condition, this.thenSchema);
+
+        // Set the default schema (used when condition is false)
+        const result = this.builder.default(elseSchema);
+
+        // Return with type information for TypeScript inference
+        return result as ConditionalResult<TThen, TElse>;
+    }
+
+    /**
+     * Alias for else() - for backward compatibility
+     */
+    default<TElse extends string>(defaultSchema: TElse): ConditionalResult<TThen, TElse> {
+        return this.else(defaultSchema);
+    }
+
+    /**
+     * Build without else clause (same as calling .else(undefined))
+     */
+    build(): any {
+        this.builder.addCondition(this.condition, this.thenSchema);
+        return this.builder.build();
+    }
+}

package/src/core/schema/extensions/components/ConditionalValidation/ConditionalThen.ts

@@ -0,0 +1,33 @@
+import { ConditionalBuilder } from "./ConditionalBuilder";
+import { ConditionalElse } from "./ConditionalElse";
+
+// Type helper to infer field types from schema strings
+type InferFieldType<T extends string> =
+    T extends "string" ? string :
+    T extends "string?" ? string | undefined :
+    T extends "number" ? number :
+    T extends "number?" ? number | undefined :
+    T extends "boolean" ? boolean :
+    T extends "boolean?" ? boolean | undefined :
+    T extends "string[]" ? string[] :
+    T extends "string[]?" ? string[] | undefined :
+    T extends "number[]" ? number[] :
+    T extends "number[]?" ? number[] | undefined :
+    T extends "boolean[]" ? boolean[] :
+    T extends "boolean[]?" ? boolean[] | undefined :
+    T extends `${string}|${string}` ? string :
+    any;
+
+/**
+ * Builder for the "then" part of conditional validation with TypeScript inference
+ */
+export class ConditionalThen {
+    constructor(
+        private builder: ConditionalBuilder,
+        private condition: (value: any) => boolean
+    ) {}
+
+    then<T extends string>(schema: T): ConditionalElse<T> {
+        return new ConditionalElse(this.builder, this.condition, schema);
+    }
+}

package/src/core/schema/extensions/components/ConditionalValidation/Extend.ts

@@ -0,0 +1,75 @@
+import { SchemaInterface } from "../../../../types/SchemaValidator.type";
+
+/**
+ * schema composition with inheritance
+ */
+export const Extend = {
+  /**
+   * Create schema inheritance with method-like syntax
+   *
+   * @example
+   * ```typescript
+   * const BaseEntitySchema = Interface({
+   *   id: "uuid",
+   *   createdAt: "date",
+   *   updatedAt: "date"
+   * });
+   *
+   * const UserSchema = Extend.from(BaseEntitySchema).with({
+   *   email: "email",
+   *   username: "string(3,20)",
+   *   profile: {
+   *     firstName: "string",
+   *     lastName: "string"
+   *   }
+   * });
+   *
+   * const AdminSchema = Extend.from(UserSchema).with({
+   *   permissions: "string[]",
+   *   role: Make.const("admin")
+   * }).override({
+   *   email: "email(,254)"  // Override with more specific validation
+   * });
+   * ```
+   */
+  from(baseSchema: SchemaInterface): ExtendBuilder {
+    return new ExtendBuilder(baseSchema);
+  },
+};
+
+/**
+ * Builder for schema extension
+ */
+export class ExtendBuilder {
+  constructor(private baseSchema: SchemaInterface) {}
+
+  with(additionalFields: any): ExtendWithBuilder {
+    return new ExtendWithBuilder(this.baseSchema, additionalFields);
+  }
+}
+
+/**
+ * Builder for extended schema with additional methods
+ */
+export class ExtendWithBuilder {
+  constructor(
+    private baseSchema: SchemaInterface,
+    private additionalFields: any
+  ) {}
+
+  override(overrides: any): SchemaInterface {
+    // Merge base schema, additional fields, and overrides
+    return {
+      ...this.baseSchema,
+      ...this.additionalFields,
+      ...overrides,
+    } as SchemaInterface;
+  }
+
+  build(): SchemaInterface {
+    return {
+      ...this.baseSchema,
+      ...this.additionalFields,
+    } as SchemaInterface;
+  }
+}

package/src/core/schema/extensions/components/ConditionalValidation/MultiConditionalBuilder.ts

@@ -0,0 +1,16 @@
+import { MultiConditionalThen } from "./MultiConditionalThen";
+
+/**
+ * Builder for multi-field conditional validation
+ */
+export class MultiConditionalBuilder {
+    private matchConditions: any = {};
+
+    constructor(private fieldNames: string[]) {}
+
+    match(conditions: Record<string, any>): MultiConditionalThen {
+        this.matchConditions = conditions;
+        return new MultiConditionalThen(this, conditions);
+    }
+}
+  

package/src/core/schema/extensions/components/ConditionalValidation/MultiConditionalThen.ts

@@ -0,0 +1,50 @@
+import { MultiConditionalBuilder } from "./MultiConditionalBuilder";
+
+/**
+ * Builder for multi-field "then" part
+ */
+export class MultiConditionalThen {
+    constructor(
+        private builder: MultiConditionalBuilder,
+        private conditions: Record<string, any>
+    ) {}
+
+    then(schema: any): MultiConditionalElse {
+        return new MultiConditionalElse(schema, null);
+    }
+}
+
+
+
+
+/**
+ * Builder for multi-field "else" part
+ */
+export class MultiConditionalElse {
+    constructor(
+        private thenSchema: any,
+        private elseSchema: any
+    ) {}
+
+    else(schema: any): any {
+        return {
+            __multiConditional: true,
+            then: this.thenSchema,
+            else: schema
+        };
+    }
+}
+
+/**
+ * Custom validator builder
+ */
+export class CustomValidator {
+    constructor(private validator: (data: any) => { valid: true } | { error: string }) {}
+
+    build(): any {
+        return {
+            __customValidator: true,
+            validator: this.validator
+        };
+    }
+}