reliant-type 1.0.0

package/src/core/schema/extensions/SmartInference.ts

@@ -0,0 +1,224 @@
+/**
+ * Smart Schema Inference - TypeScript type-to-schema conversion
+ *
+ * This module provides automatic schema generation from TypeScript types,
+ * making schema definition even more seamless.
+ */
+
+import { SchemaInterface } from "../mode/interfaces/Interface";
+
+/**
+ * Smart inference utilities for automatic schema generation
+ */
+export const Smart = {
+  /**
+   * Infer schema from TypeScript interface using runtime reflection
+   *
+   * @example
+   * ```typescript
+   * interface User {
+   *   id: number;
+   *   email: string;
+   *   name?: string;
+   * }
+   *
+   * // Use with sample data that matches your interface
+   * const UserSchema = Smart.fromType<User>({
+   *   id: 1,
+   *   email: "user@example.com",
+   *   name: "John Doe"
+   * });
+   * // Generates: Interface({ id: "positive", email: "email", name: "string?" })
+   * ```
+   */
+  fromType<T>(sampleData: T): SchemaInterface {
+    if (!sampleData || typeof sampleData !== "object") {
+      throw new Error(
+        "Smart.fromType() requires sample data that matches your TypeScript interface"
+      );
+    }
+
+    return Smart.fromSample(sampleData);
+  },
+
+  /**
+   * Infer schema from sample data with intelligent type detection
+   *
+   * @example
+   * ```typescript
+   * const sampleUser = {
+   *   id: 1,
+   *   email: "user@example.com",
+   *   name: "John Doe",
+   *   tags: ["developer", "typescript"]
+   * };
+   *
+   * const UserSchema = Smart.fromSample(sampleUser);
+   * // Generates: Interface({ id: "positive", email: "email", name: "string", tags: "string[]" })
+   * ```
+   */
+  fromSample(sample: any): SchemaInterface {
+    const schema: any = {};
+
+    for (const [key, value] of Object.entries(sample)) {
+      schema[key] = Smart.inferFieldType(value);
+    }
+
+    return schema;
+  },
+
+  /**
+   * Infer field type from value with smart detection
+   */
+  inferFieldType(value: any): string {
+    if (value === null || value === undefined) {
+      return "any?";
+    }
+
+    if (typeof value === "string") {
+      // Smart email detection
+      if (Smart.isEmail(value)) return "email";
+      // Smart URL detection
+      if (Smart.isUrl(value)) return "url";
+      // Smart UUID detection
+      if (Smart.isUuid(value)) return "uuid";
+      // Smart phone detection
+      if (Smart.isPhone(value)) return "phone";
+
+      return "string";
+    }
+
+    if (typeof value === "number") {
+      // Smart positive number detection
+      if (value > 0 && Number.isInteger(value)) return "positive";
+      if (Number.isInteger(value)) return "int";
+      return "number";
+    }
+
+    if (typeof value === "boolean") {
+      return "boolean";
+    }
+
+    if (value instanceof Date) {
+      return "date";
+    }
+
+    if (Array.isArray(value)) {
+      if (value.length === 0) return "any[]";
+
+      // Detect array element type from first element
+      const elementType = Smart.inferFieldType(value[0]);
+      const baseType = elementType.replace("?", ""); // Remove optional marker
+      return `${baseType}[]`;
+    }
+
+    if (typeof value === "object") {
+      // Nested object - recursively infer
+      const nestedSchema: any = {};
+      for (const [nestedKey, nestedValue] of Object.entries(value)) {
+        nestedSchema[nestedKey] = Smart.inferFieldType(nestedValue);
+      }
+      return nestedSchema;
+    }
+
+    return "any";
+  },
+
+  /**
+   * Smart format detection utilities
+   */
+  isEmail(str: string): boolean {
+    return /^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(str);
+  },
+
+  isUrl(str: string): boolean {
+    try {
+      new URL(str);
+      return true;
+    } catch {
+      return false;
+    }
+  },
+
+  isUuid(str: string): boolean {
+    return /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(
+      str
+    );
+  },
+
+  isPhone(str: string): boolean {
+    return /^\+?[1-9]\d{1,14}$/.test(str.replace(/[\s\-\(\)]/g, ""));
+  },
+
+  /**
+   * Generate schema from JSON Schema (migration helper)
+   *
+   * @example
+   * ```typescript
+   * const jsonSchema = {
+   *   type: "object",
+   *   properties: {
+   *     id: { type: "number" },
+   *     email: { type: "string", format: "email" }
+   *   }
+   * };
+   *
+   * const schema = Smart.fromJsonSchema(jsonSchema);
+   * ```
+   */
+  fromJsonSchema(jsonSchema: any): SchemaInterface {
+    if (jsonSchema.type === "object" && jsonSchema.properties) {
+      const schema: any = {};
+
+      for (const [key, prop] of Object.entries(jsonSchema.properties as any)) {
+        schema[key] = Smart.convertJsonSchemaProperty(prop);
+      }
+
+      return schema;
+    }
+
+    throw new Error("Unsupported JSON Schema format");
+  },
+
+  convertJsonSchemaProperty(prop: any): string {
+    const isOptional = !prop.required;
+    const suffix = isOptional ? "?" : "";
+
+    switch (prop.type) {
+      case "string":
+        if (prop.format === "email") return `email${suffix}`;
+        if (prop.format === "uri") return `url${suffix}`;
+        if (prop.format === "uuid") return `uuid${suffix}`;
+        if (prop.minLength && prop.maxLength) {
+          return `string(${prop.minLength},${prop.maxLength})${suffix}`;
+        }
+        return `string${suffix}`;
+
+      case "number":
+      case "integer":
+        if (prop.minimum && prop.maximum) {
+          return `number(${prop.minimum},${prop.maximum})${suffix}`;
+        }
+        if (prop.minimum > 0) return `positive${suffix}`;
+        return prop.type === "integer" ? `int${suffix}` : `number${suffix}`;
+
+      case "boolean":
+        return `boolean${suffix}`;
+
+      case "array":
+        const itemType = Smart.convertJsonSchemaProperty(
+          prop.items || { type: "any" }
+        );
+        const baseType = itemType.replace("?", "");
+        return `${baseType}[]${suffix}`;
+
+      default:
+        return `any${suffix}`;
+    }
+  },
+};
+
+/**
+ * Export for easy access
+ */
+export default Smart;

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

@@ -0,0 +1,98 @@
+import { Documentation, DocumentationOptions, InteractiveDocumentation, InteractiveOptions } from "../../../../types/extension.type";
+import { SchemaInterface } from "../../../../types/SchemaValidator.type";
+import { OpenAPIConverter, OpenAPISpecification, OpenAPISpecOptions } from "../../mods";
+import { TSGenerator ,  TypeScriptOptions as TSOptions} from "../../mods/typescript-generator";
+import { DocumentationGenerator, InteractiveDocumentationGenerator } from ".";
+
+/**
+ * Auto documentation utilities
+ */
+export const Docs = {
+    /**
+     * Generate comprehensive documentation from schema
+     *
+     * @example
+     * ```typescript
+     * const UserSchema = Interface({
+     *   id: "uuid",
+     *   email: "email",
+     *   name: "string(2,50)",
+     *   age: "int(18,120)?",
+     *   role: Make.union("user", "admin", "moderator")
+     * });
+     *
+     * const documentation = Docs.generate(UserSchema, {
+     *   title: "User API",
+     *   description: "User management endpoints",
+     *   examples: true,
+     *   interactive: true
+     * });
+     *
+     * console.log(documentation.markdown);
+     * console.log(documentation.html);
+     * console.log(documentation.openapi);
+     * ```
+     */
+    generate(schema: SchemaInterface, options: DocumentationOptions = {}): Documentation {
+        return new DocumentationGenerator(schema, options).generate();
+    },
+
+    /**
+     * Generate OpenAPI specification from schema
+     *
+     * @example
+     * ```typescript
+     * const openApiSpec = Docs.openapi(UserSchema, {
+     *   title: "User API",
+     *   version: "1.0.0",
+     *   servers: ["https://api.example.com"]
+     * });
+     * ```
+     */
+    openapi(schema: SchemaInterface, options: OpenAPISpecOptions): OpenAPISpecification {
+        return OpenAPIConverter.generateOpenAPISpec(schema, options);
+    },
+
+    /**
+     * Generate TypeScript type definitions
+     *
+     * @example
+     * ```typescript
+     * const typeDefinitions = Docs.typescript(UserSchema, {
+     *   exportName: "User",
+     *   namespace: "API"
+     * });
+     *
+     * // Generates:
+     * // export interface User {
+     * //   id: string;
+     * //   email: string;
+     * //   name: string;
+     * //   age?: number;
+     * //   role: "user" | "admin" | "moderator";
+     * // }
+     * ```
+     */
+    typescript(schema: SchemaInterface, options: TSOptions = {}): string {
+        return TSGenerator.generateInterface(schema, options);
+    },
+
+    /**
+     * Generate interactive documentation with live examples
+     *
+     * @example
+     * ```typescript
+     * const interactiveDocs = Docs.interactive(UserSchema, {
+     *   title: "User Schema Playground",
+     *   theme: "dark",
+     *   showExamples: true,
+     *   allowTesting: true
+     * });
+     *
+     * document.body.innerHTML = interactiveDocs.html;
+     * ```
+     */
+    interactive(schema: SchemaInterface, options: InteractiveOptions = {}): InteractiveDocumentation {
+        return new InteractiveDocumentationGenerator(schema, options).generate();
+    }
+};

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

@@ -0,0 +1,201 @@
+import { Documentation, DocumentationOptions, FieldInfo, OpenAPISpec, SchemaAnalysis } from "../../../../types/extension.type";
+import { SchemaInterface } from "../../../../types/SchemaValidator.type";
+import { SchemaAnalyzer } from "./SchemaAnalyzer";
+
+/**
+ * Main documentation generator
+ */
+export class DocumentationGenerator {
+    constructor(
+        private schema: SchemaInterface,
+        private options: DocumentationOptions
+    ) {}
+
+    generate(): Documentation {
+        const analyzer = new SchemaAnalyzer(this.schema);
+        const analysis = analyzer.analyze();
+
+        return {
+            markdown: this.generateMarkdown(analysis),
+            html: this.generateHTML(analysis),
+            openapi: this.generateOpenAPI(analysis),
+            json: this.generateJSON(analysis),
+            examples: this.generateExamples(analysis)
+        };
+    }
+
+    private generateMarkdown(analysis: SchemaAnalysis): string {
+        const { title = "Schema Documentation", description = "" } = this.options;
+
+        let markdown = `# ${title}\n\n`;
+        if (description) {
+            markdown += `${description}\n\n`;
+        }
+
+        markdown += "## Schema Structure\n\n";
+        markdown += this.generateFieldTable(analysis.fields);
+
+        if (this.options.examples) {
+            markdown += "\n## Examples\n\n";
+            markdown += this.generateExampleMarkdown(analysis);
+        }
+
+        return markdown;
+    }
+
+    private generateHTML(analysis: SchemaAnalysis): string {
+        const { title = "Schema Documentation" } = this.options;
+
+        return `
+<!DOCTYPE html>
+<html>
+<head>
+    <title>${title}</title>
+    <style>
+        body { font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', sans-serif; }
+        .field { margin: 1rem 0; padding: 1rem; border: 1px solid #e1e5e9; border-radius: 6px; }
+        .field-name { font-weight: bold; color: #0366d6; }
+        .field-type { color: #6f42c1; font-family: monospace; }
+        .field-description { color: #586069; margin-top: 0.5rem; }
+        .example { background: #f6f8fa; padding: 1rem; border-radius: 6px; margin: 1rem 0; }
+        pre { background: #f6f8fa; padding: 1rem; border-radius: 6px; overflow-x: auto; }
+    </style>
+</head>
+<body>
+    <h1>${title}</h1>
+    ${this.generateFieldHTML(analysis.fields)}
+    ${this.options.examples ? this.generateExampleHTML(analysis) : ''}
+</body>
+</html>`;
+    }
+
+    private generateOpenAPI(analysis: SchemaAnalysis): OpenAPISpec {
+        return {
+            openapi: "3.0.0",
+            info: {
+                title: this.options.title || "API Documentation",
+                version: "1.0.0"
+            },
+            components: {
+                schemas: {
+                    [this.options.title || "Schema"]: this.convertToOpenAPISchema(analysis)
+                }
+            }
+        };
+    }
+
+    private generateJSON(analysis: SchemaAnalysis): any {
+        return {
+            schema: this.schema,
+            analysis,
+            metadata: {
+                generatedAt: new Date().toISOString(),
+                version: "1.0.0"
+            }
+        };
+    }
+
+    private generateExamples(analysis: SchemaAnalysis): any[] {
+        return [
+            this.generateValidExample(analysis),
+            this.generateInvalidExample(analysis)
+        ];
+    }
+
+    private generateFieldTable(fields: FieldInfo[]): string {
+        let table = "| Field | Type | Required | Description |\n";
+        table += "|-------|------|----------|-------------|\n";
+
+        fields.forEach(field => {
+            table += `| ${field.name} | \`${field.type}\` | ${field.required ? 'Yes' : 'No'} | ${field.description || ''} |\n`;
+        });
+
+        return table;
+    }
+
+    private generateFieldHTML(fields: FieldInfo[]): string {
+        return fields.map(field => `
+            <div class="field">
+                <div class="field-name">${field.name}</div>
+                <div class="field-type">${field.type}</div>
+                <div class="field-description">${field.description || ''}</div>
+            </div>
+        `).join('');
+    }
+
+    private generateExampleMarkdown(analysis: SchemaAnalysis): string {
+        const example = this.generateValidExample(analysis);
+        return `\`\`\`json\n${JSON.stringify(example, null, 2)}\n\`\`\``;
+    }
+
+    private generateExampleHTML(analysis: SchemaAnalysis): string {
+        const example = this.generateValidExample(analysis);
+        return `<div class="example"><pre>${JSON.stringify(example, null, 2)}</pre></div>`;
+    }
+
+    private generateValidExample(analysis: SchemaAnalysis): any {
+        const example: any = {};
+
+        analysis.fields.forEach(field => {
+            if (field.required || Math.random() > 0.3) { // Include some optional fields
+                example[field.name] = this.generateExampleValue(field.type);
+            }
+        });
+
+        return example;
+    }
+
+    private generateInvalidExample(analysis: SchemaAnalysis): any {
+        const example = this.generateValidExample(analysis);
+        // Introduce some invalid data
+        if (example.email) example.email = "invalid-email";
+        if (example.age) example.age = -5;
+        return example;
+    }
+
+    private generateExampleValue(type: string): any {
+        if (type === "email") return "user@example.com";
+        if (type === "uuid") return "550e8400-e29b-41d4-a716-446655440000";
+        if (type === "url") return "https://example.com";
+        if (type.startsWith("string")) return "Example string";
+        if (type.includes("number") || type === "positive" || type === "int") return 42;
+        if (type === "boolean") return true;
+        if (type === "date") return new Date().toISOString();
+        if (type.includes("[]")) return ["item1", "item2"];
+        return "example";
+    }
+
+    private convertToOpenAPISchema(analysis: SchemaAnalysis): any {
+        const properties: any = {};
+        const required: string[] = [];
+
+        analysis.fields.forEach(field => {
+            properties[field.name] = this.convertFieldToOpenAPI(field);
+            if (field.required) {
+                required.push(field.name);
+            }
+        });
+
+        return {
+            type: "object",
+            properties,
+            required
+        };
+    }
+
+    private convertFieldToOpenAPI(field: FieldInfo): any {
+        const type = field.type;
+
+        if (type === "email") return { type: "string", format: "email" };
+        if (type === "uuid") return { type: "string", format: "uuid" };
+        if (type === "url") return { type: "string", format: "uri" };
+        if (type.startsWith("string")) return { type: "string" };
+        if (type.includes("number") || type === "positive" || type === "int") return { type: "number" };
+        if (type === "boolean") return { type: "boolean" };
+        if (type === "date") return { type: "string", format: "date-time" };
+        if (type.includes("[]")) return { type: "array", items: { type: "string" } };
+
+        return { type: "string" };
+    }
+}
+

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

@@ -0,0 +1,176 @@
+import { InteractiveDocumentation, InteractiveOptions } from "../../../../types/extension.type";
+import { SchemaInterface } from "../../../../types/SchemaValidator.type";
+
+/**
+ * Interactive documentation generator
+ */
+export class InteractiveDocumentationGenerator {
+    constructor(
+        private schema: SchemaInterface,
+        private options: InteractiveOptions
+    ) {}
+
+    generate(): InteractiveDocumentation {
+        return {
+            html: this.generateInteractiveHTML(),
+            css: this.generateCSS(),
+            javascript: this.generateJavaScript()
+        };
+    }
+
+    private generateInteractiveHTML(): string {
+        return `
+<div id="schema-playground">
+    <h1>${this.options.title || 'Schema Playground'}</h1>
+    <div class="playground-container">
+        <div class="schema-panel">
+            <h2>Schema</h2>
+            <pre id="schema-display"></pre>
+        </div>
+        <div class="input-panel">
+            <h2>Test Data</h2>
+            <textarea id="test-input" placeholder="Enter JSON data to validate..."></textarea>
+            <button id="validate-btn">Validate</button>
+        </div>
+        <div class="result-panel">
+            <h2>Result</h2>
+            <div id="validation-result"></div>
+        </div>
+    </div>
+</div>`;
+    }
+
+    private generateCSS(): string {
+        return `
+.playground-container { display: grid; grid-template-columns: 1fr 1fr 1fr; gap: 1rem; }
+.schema-panel, .input-panel, .result-panel { border: 1px solid #e1e5e9; border-radius: 6px; padding: 1rem; }
+#test-input { width: 100%; height: 200px; font-family: monospace; }
+#validate-btn { background: #0366d6; color: white; border: none; padding: 0.5rem 1rem; border-radius: 4px; cursor: pointer; }
+.valid { color: #28a745; }
+.invalid { color: #dc3545; }`;
+    }
+
+    private generateJavaScript(): string {
+        const schemaStr = JSON.stringify(this.schema, null, 2);
+        return `
+document.getElementById('schema-display').textContent = ${schemaStr};
+
+// Real validation function
+function validateData(schema, data) {
+    const errors = [];
+
+    for (const [fieldName, fieldType] of Object.entries(schema)) {
+        const value = data[fieldName];
+        const fieldErrors = validateField(fieldType, value, fieldName);
+        if (fieldErrors.length > 0) {
+            errors.push(...fieldErrors);
+        }
+    }
+
+    return errors;
+}
+
+function validateField(fieldType, value, fieldName) {
+    const errors = [];
+
+    if (typeof fieldType === 'string') {
+        const isOptional = fieldType.includes('?');
+        const cleanType = fieldType.replace('?', '');
+
+        // Handle null/undefined for optional fields
+        if (isOptional && (value === null || value === undefined)) {
+            return errors;
+        }
+
+        // Required field cannot be null/undefined
+        if (!isOptional && (value === null || value === undefined)) {
+            errors.push(fieldName + ': Field is required');
+            return errors;
+        }
+
+        // Type-specific validation
+        if (cleanType === 'email') {
+            if (typeof value !== 'string' || !/^[^\\s@]+@[^\\s@]+\\.[^\\s@]+$/.test(value)) {
+                errors.push(fieldName + ': Invalid email format');
+            }
+        } else if (cleanType === 'url') {
+            if (typeof value !== 'string') {
+                errors.push(fieldName + ': URL must be a string');
+            } else {
+                try {
+                    new URL(value);
+                } catch {
+                    errors.push(fieldName + ': Invalid URL format');
+                }
+            }
+        } else if (cleanType === 'uuid') {
+            if (typeof value !== 'string' || !/^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(value)) {
+                errors.push(fieldName + ': Invalid UUID format');
+            }
+        } else if (cleanType === 'number') {
+            if (typeof value !== 'number' || isNaN(value)) {
+                errors.push(fieldName + ': Must be a valid number');
+            }
+        } else if (cleanType === 'positive') {
+            if (typeof value !== 'number' || isNaN(value) || value <= 0) {
+                errors.push(fieldName + ': Must be a positive number');
+            }
+        } else if (cleanType === 'int') {
+            if (typeof value !== 'number' || isNaN(value) || !Number.isInteger(value)) {
+                errors.push(fieldName + ': Must be an integer');
+            }
+        } else if (cleanType === 'boolean') {
+            if (typeof value !== 'boolean') {
+                errors.push(fieldName + ': Must be a boolean');
+            }
+        } else if (cleanType === 'string') {
+            if (typeof value !== 'string') {
+                errors.push(fieldName + ': Must be a string');
+            }
+        } else if (cleanType.startsWith('string(')) {
+            if (typeof value !== 'string') {
+                errors.push(fieldName + ': Must be a string');
+            } else {
+                const match = cleanType.match(/string\\((\\d+)?,?(\\d+)?\\)/);
+                if (match) {
+                    const minLength = match[1] ? parseInt(match[1]) : 0;
+                    const maxLength = match[2] ? parseInt(match[2]) : Infinity;
+                    if (value.length < minLength) {
+                        errors.push(fieldName + ': String too short (min ' + minLength + ')');
+                    }
+                    if (value.length > maxLength) {
+                        errors.push(fieldName + ': String too long (max ' + maxLength + ')');
+                    }
+                }
+            }
+        } else if (cleanType.includes('[]')) {
+            if (!Array.isArray(value)) {
+                errors.push(fieldName + ': Must be an array');
+            }
+        }
+    }
+
+    return errors;
+}
+
+document.getElementById('validate-btn').addEventListener('click', function() {
+    const input = document.getElementById('test-input').value;
+    const result = document.getElementById('validation-result');
+
+    try {
+        const data = JSON.parse(input);
+        const schema = ${schemaStr};
+        const validationErrors = validateData(schema, data);
+
+        if (validationErrors.length === 0) {
+            result.innerHTML = '<div class="valid">✓ Valid data</div>';
+        } else {
+            result.innerHTML = '<div class="invalid">✗ Validation errors:<br>' +
+                validationErrors.map(err => '• ' + err).join('<br>') + '</div>';
+        }
+    } catch (e) {
+        result.innerHTML = '<div class="invalid">✗ Invalid JSON: ' + e.message + '</div>';
+    }
+});`;
+    }
+}