reliant-type 1.0.0 → 2.1.3

package/src/core/schema/extensions/mods/typescript-generator.ts

@@ -6,237 +6,284 @@
  */
 
 import { SchemaInterface } from "../../mode/interfaces/Interface";
+import { TypeGuards } from "../../mode/interfaces/validators/TypeGuards";
 
 /**
  * TypeScript code generator for schema definitions
  */
 export class TypeScriptGenerator {
-    /**
-     * Generate TypeScript interface from schema
-     */
-    static generateInterface(
-        schema: SchemaInterface,
-        options: TypeScriptOptions = {}
-    ): string {
-        const { exportName = "Schema", namespace, exportType = "interface" } = options;
-
-        // Extract the actual field definitions from the schema
-        const fieldDefinitions = this.extractFieldDefinitions(schema);
-
-        let output = "";
-
-        // Add namespace if specified
-        if (namespace) {
-            output += `export namespace ${namespace} {\n`;
-        }
-
-        // Generate interface or type
-        if (exportType === "interface") {
-            output += this.generateInterfaceDefinition(fieldDefinitions, exportName, namespace ? 1 : 0);
-        } else {
-            output += this.generateTypeDefinition(fieldDefinitions, exportName, namespace ? 1 : 0);
-        }
+  /**
+   * Generate TypeScript interface from schema
+   */
+  static generateInterface(
+    schema: SchemaInterface,
+    options: TypeScriptOptions = {}
+  ): string {
+    const {
+      exportName = "Schema",
+      namespace,
+      exportType = "interface",
+    } = options;
+
+    // Extract the actual field definitions from the schema
+    const fieldDefinitions = this.extractFieldDefinitions(schema);
+
+    let output = "";
+
+    // Add namespace if specified
+    if (namespace) {
+      output += `export namespace ${namespace} {\n`;
+    }
 
-        // Close namespace if specified
-        if (namespace) {
-            output += "}\n";
-        }
+    // Generate interface or type
+    if (exportType === "interface") {
+      output += this.generateInterfaceDefinition(
+        fieldDefinitions,
+        exportName,
+        namespace ? 1 : 0
+      );
+    } else {
+      output += this.generateTypeDefinition(
+        fieldDefinitions,
+        exportName,
+        namespace ? 1 : 0
+      );
+    }
 
-        return output;
+    // Close namespace if specified
+    if (namespace) {
+      output += "}\n";
     }
 
-    /**
-     * Extract field definitions from schema object
-     */
-    private static extractFieldDefinitions(schema: any): Record<string, any> {
-        // If schema has a definition property, use that
-        if (schema && typeof schema === 'object' && schema.definition) {
-            return schema.definition;
-        }
+    return output;
+  }
 
-        // Otherwise, assume the schema itself contains the field definitions
-        return schema;
+  /**
+   * Extract field definitions from schema object
+   */
+  private static extractFieldDefinitions(schema: any): Record<string, any> {
+    // If schema has a definition property, use that
+    if (schema && typeof schema === "object" && schema.definition) {
+      return schema.definition;
     }
 
-    /**
-     * Generate interface definition
-     */
-    private static generateInterfaceDefinition(
-        schema: SchemaInterface,
-        name: string,
-        indentLevel: number = 0
-    ): string {
-        const indent = "  ".repeat(indentLevel);
-        let output = `${indent}export interface ${name} {\n`;
-
-        Object.entries(schema).forEach(([fieldName, fieldType]) => {
-            const tsType = this.convertToTypeScript(fieldType);
-            const optional = this.isOptionalField(fieldType) ? "?" : "";
-            output += `${indent}  ${fieldName}${optional}: ${tsType};\n`;
-        });
-
-        output += `${indent}}\n`;
-        return output;
+    // Otherwise, assume the schema itself contains the field definitions
+    return schema;
+  }
+
+  /**
+   * Generate interface definition
+   */
+  private static generateInterfaceDefinition(
+    schema: SchemaInterface,
+    name: string,
+    indentLevel: number = 0
+  ): string {
+    const indent = "  ".repeat(indentLevel);
+    let output = `${indent}export interface ${name} {\n`;
+
+    Object.entries(schema).forEach(([fieldName, fieldType]) => {
+      const tsType = this.convertToTypeScript(fieldType, indentLevel + 1);
+      const optional = this.isOptionalField(fieldType) ? "?" : "";
+      output += `${indent}  ${fieldName}${optional}: ${tsType};\n`;
+    });
+
+    output += `${indent}}\n`;
+    return output;
+  }
+
+  /**
+   * Generate type alias definition
+   */
+  private static generateTypeDefinition(
+    schema: SchemaInterface,
+    name: string,
+    indentLevel: number = 0
+  ): string {
+    const indent = "  ".repeat(indentLevel);
+    const objectType = this.convertObjectToTypeScript(schema, indentLevel);
+    return `${indent}export type ${name} = ${objectType};\n`;
+  }
+
+  /**
+   * Convert schema field to TypeScript type
+   */
+  private static convertToTypeScript(
+    fieldType: any,
+    indentLevel: number = 0
+  ): string {
+    // Handle OptionalSchemaInterface wrapper
+    if (TypeGuards.isOptionalSchemaInterface(fieldType)) {
+      return this.convertToTypeScript(fieldType.schema, indentLevel);
     }
 
-    /**
-     * Generate type alias definition
-     */
-    private static generateTypeDefinition(
-        schema: SchemaInterface,
-        name: string,
-        indentLevel: number = 0
-    ): string {
-        const indent = "  ".repeat(indentLevel);
-        const objectType = this.convertObjectToTypeScript(schema);
-        return `${indent}export type ${name} = ${objectType};\n`;
+    if (typeof fieldType === "string") {
+      return this.convertStringToTypeScript(fieldType);
     }
 
-    /**
-     * Convert schema field to TypeScript type
-     */
-    private static convertToTypeScript(fieldType: any): string {
-        if (typeof fieldType === "string") {
-            return this.convertStringToTypeScript(fieldType);
-        }
-
-        if (typeof fieldType === "object" && !Array.isArray(fieldType)) {
-            // Handle Make.union() objects
-            if (fieldType.union && Array.isArray(fieldType.union)) {
-                return fieldType.union.map((value: any) => `"${value}"`).join(" | ");
-            }
-
-            // Handle Make.const() objects
-            if (fieldType.const !== undefined) {
-                return `"${fieldType.const}"`;
-            }
+    if (typeof fieldType === "object" && !Array.isArray(fieldType)) {
+      // Handle Make.union() objects
+      if (fieldType.union && Array.isArray(fieldType.union)) {
+        return fieldType.union.map((value: any) => `"${value}"`).join(" | ");
+      }
 
-            return this.convertObjectToTypeScript(fieldType);
-        }
+      // Handle Make.const() objects
+      if (fieldType.const !== undefined) {
+        return `"${fieldType.const}"`;
+      }
 
-        return "any";
+      return this.convertObjectToTypeScript(fieldType, indentLevel);
     }
 
-    /**
-     * Convert string-based field to TypeScript type
-     */
-    private static convertStringToTypeScript(fieldType: string): string {
-        const cleanType = fieldType.replace("?", "");
-
-        // Handle arrays FIRST - before other checks
-        if (cleanType.includes("[]")) {
-            const elementType = cleanType.replace("[]", "").replace(/\([^)]*\)/, ""); // Remove constraints
-            const tsElementType = this.convertStringToTypeScript(elementType);
-            return `${tsElementType}[]`;
-        }
-
-        // Handle number types with constraints
-        if (cleanType.startsWith("number(") || cleanType.includes("number(")) {
-            return "number";
-        }
-
-        // Basic type mappings
-        const typeMappings: Record<string, string> = {
-            email: "string",
-            url: "string",
-            uuid: "string",
-            phone: "string",
-            date: "Date",
-            number: "number",
-            positive: "number",
-            int: "number",
-            boolean: "boolean",
-            string: "string"
-        };
-
-        // Check for direct mapping
-        if (typeMappings[cleanType]) {
-            return typeMappings[cleanType];
-        }
+    if (Array.isArray(fieldType) && fieldType.length === 1) {
+      return `${this.convertToTypeScript(fieldType[0], indentLevel)}[]`;
+    }
 
-        // Handle string with constraints
-        if (cleanType.startsWith("string")) {
-            return "string";
-        }
+    return "any";
+  }
 
-        // Handle union types (pipe-separated values)
-        if (cleanType.includes("|")) {
-            const unionTypes = cleanType.split("|").map(t => `"${t.trim()}"`);
-            return unionTypes.join(" | ");
-        }
+  /**
+   * Convert string-based field to TypeScript type
+   */
+  private static convertStringToTypeScript(fieldType: string): string {
+    const cleanType = fieldType.replace("?", "");
 
-        return "string";
+    // Handle function types
+    if (TypeGuards.isFunctionType(fieldType)) {
+      const type = fieldType.endsWith("?") ? fieldType.slice(0, -1) : fieldType;
+      const signature = type.slice(3, -1); // remove fn( and )
+      return signature.replace(/TYPE/g, "any");
     }
 
-    /**
-     * Convert object to TypeScript type
-     */
-    private static convertObjectToTypeScript(obj: any): string {
-        if (typeof obj !== "object" || obj === null) {
-            return "any";
-        }
+    // Handle arrays FIRST - before other checks
+    if (cleanType.includes("[]")) {
+      const elementType = cleanType.replace("[]", "").replace(/\([^)]*\)/, ""); // Remove constraints
+      const tsElementType = this.convertStringToTypeScript(elementType);
+      return `${tsElementType}[]`;
+    }
 
-        const properties: string[] = [];
+    // Handle number types with constraints
+    if (cleanType.startsWith("number(") || cleanType.includes("number(")) {
+      return "number";
+    }
 
-        Object.entries(obj).forEach(([key, value]) => {
-            const tsType = this.convertToTypeScript(value);
-            const optional = this.isOptionalField(value) ? "?" : "";
-            properties.push(`${key}${optional}: ${tsType}`);
-        });
+    // Basic type mappings
+    const typeMappings: Record<string, string> = {
+      email: "string",
+      url: "string",
+      uuid: "string",
+      phone: "string",
+      date: "Date",
+      number: "number",
+      positive: "number",
+      int: "number",
+      boolean: "boolean",
+      string: "string",
+      object: "Record<string, any>",
+      any: "any",
+      record: "Record<string, any>",
+    };
+
+    // Check for direct mapping
+    if (typeMappings[cleanType]) {
+      return typeMappings[cleanType];
+    }
 
-        return `{\n  ${properties.join(";\n  ")};\n}`;
+    // Handle string with constraints
+    if (cleanType.startsWith("string")) {
+      return "string";
     }
 
-    /**
-     * Check if field is optional
-     */
-    private static isOptionalField(fieldType: any): boolean {
-        if (typeof fieldType === "string") {
-            return fieldType.includes("?");
-        }
-        return false;
+    // Handle union types (pipe-separated values)
+    if (cleanType.includes("|")) {
+      const unionTypes = cleanType.split("|").map((t) => {
+        const trimmed = t.trim();
+        // If it's a known type, use its mapping, otherwise treat as literal
+        return typeMappings[trimmed] || `"${trimmed}"`;
+      });
+      return unionTypes.join(" | ");
     }
 
-    /**
-     * Generate utility types for schema
-     */
-    static generateUtilityTypes(
-        schema: SchemaInterface,
-        baseName: string
-    ): string {
-        let output = "";
-
-        // Generate partial type
-        output += `export type Partial${baseName} = Partial<${baseName}>;\n\n`;
-
-        // Generate required type
-        output += `export type Required${baseName} = Required<${baseName}>;\n\n`;
-
-        // Generate pick types for common field combinations
-        const fields = Object.keys(schema);
-        if (fields.length > 1) {
-            output += `export type ${baseName}Keys = keyof ${baseName};\n\n`;
-
-            // Generate create type (without optional fields)
-            const requiredFields = fields.filter(field =>
-                !this.isOptionalField(schema[field])
-            );
-
-            if (requiredFields.length > 0 && requiredFields.length < fields.length) {
-                output += `export type Create${baseName} = Pick<${baseName}, ${
-                    requiredFields.map(f => `"${f}"`).join(" | ")
-                }>;\n\n`;
-            }
-        }
+    return "any"; // Changed fallback from "string" to "any"
+  }
+
+  /**
+   * Convert object to TypeScript type
+   */
+  private static convertObjectToTypeScript(
+    obj: any,
+    indentLevel: number = 0
+  ): string {
+    if (typeof obj !== "object" || obj === null) {
+      return "any";
+    }
 
-        return output;
+    const indent = "  ".repeat(indentLevel);
+    const nextIndent = "  ".repeat(indentLevel + 1);
+    const properties: string[] = [];
+
+    Object.entries(obj).forEach(([key, value]) => {
+      const tsType = this.convertToTypeScript(value, indentLevel + 1);
+      const optional = this.isOptionalField(value) ? "?" : "";
+      properties.push(`${nextIndent}${key}${optional}: ${tsType}`);
+    });
+
+    return `{\n${properties.join(";\n")};\n${indent}}`;
+  }
+
+  /**
+   * Check if field is optional
+   */
+  private static isOptionalField(fieldType: any): boolean {
+    if (TypeGuards.isOptionalSchemaInterface(fieldType)) {
+      return true;
+    }
+    if (typeof fieldType === "string") {
+      return fieldType.includes("?");
+    }
+    return false;
+  }
+
+  /**
+   * Generate utility types for schema
+   */
+  static generateUtilityTypes(
+    schema: SchemaInterface,
+    baseName: string
+  ): string {
+    let output = "";
+
+    // Generate partial type
+    output += `export type Partial${baseName} = Partial<${baseName}>;\n\n`;
+
+    // Generate required type
+    output += `export type Required${baseName} = Required<${baseName}>;\n\n`;
+
+    // Generate pick types for common field combinations
+    const fields = Object.keys(schema);
+    if (fields.length > 1) {
+      output += `export type ${baseName}Keys = keyof ${baseName};\n\n`;
+
+      // Generate create type (without optional fields)
+      const requiredFields = fields.filter(
+        (field) => !this.isOptionalField(schema[field])
+      );
+
+      if (requiredFields.length > 0 && requiredFields.length < fields.length) {
+        output += `export type Create${baseName} = Pick<${baseName}, ${requiredFields
+          .map((f) => `"${f}"`)
+          .join(" | ")}>;\n\n`;
+      }
     }
 
-    /**
-     * Generate validation function types
-     */
-    static generateValidationTypes(baseName: string): string {
-        return `
+    return output;
+  }
+
+  /**
+   * Generate validation function types
+   */
+  static generateValidationTypes(baseName: string): string {
+    return `
 export interface ${baseName}ValidationResult {
   isValid: boolean;
   data: ${baseName};
@@ -256,124 +303,124 @@ export interface ${baseName}ParseResult {
   };
 }
 `;
+  }
+
+  /**
+   * Generate complete TypeScript module
+   */
+  static generateModule(
+    schema: SchemaInterface,
+    options: ModuleOptions
+  ): string {
+    const {
+      moduleName,
+      exportName = "Schema",
+      includeUtilities = true,
+      includeValidation = true,
+      header,
+    } = options;
+
+    let output = "";
+
+    // Add header comment
+    if (header) {
+      output += `/**\n * ${header}\n */\n\n`;
     }
 
-    /**
-     * Generate complete TypeScript module
-     */
-    static generateModule(
-        schema: SchemaInterface,
-        options: ModuleOptions
-    ): string {
-        const {
-            moduleName,
-            exportName = "Schema",
-            includeUtilities = true,
-            includeValidation = true,
-            header
-        } = options;
-
-        let output = "";
-
-        // Add header comment
-        if (header) {
-            output += `/**\n * ${header}\n */\n\n`;
-        }
-
-        // Generate main interface
-        output += this.generateInterface(schema, { exportName });
-        output += "\n";
-
-        // Generate utility types
-        if (includeUtilities) {
-            output += this.generateUtilityTypes(schema, exportName);
-        }
-
-        // Generate validation types
-        if (includeValidation) {
-            output += this.generateValidationTypes(exportName);
-        }
-
-        // Add module export
-        if (moduleName) {
-            output += `\nexport const ${moduleName} = {\n`;
-            output += `  name: "${exportName}",\n`;
-            output += `  fields: ${JSON.stringify(Object.keys(schema), null, 2)}\n`;
-            output += "};\n";
-        }
+    // Generate main interface
+    output += this.generateInterface(schema, { exportName });
+    output += "\n";
 
-        return output;
+    // Generate utility types
+    if (includeUtilities) {
+      output += this.generateUtilityTypes(schema, exportName);
     }
 
-    /**
-     * Generate JSDoc comments for schema fields
-     */
-    static generateJSDoc(schema: SchemaInterface): Record<string, string> {
-        const docs: Record<string, string> = {};
-
-        Object.entries(schema).forEach(([fieldName, fieldType]) => {
-            docs[fieldName] = this.generateFieldJSDoc(fieldName, fieldType);
-        });
+    // Generate validation types
+    if (includeValidation) {
+      output += this.generateValidationTypes(exportName);
+    }
 
-        return docs;
+    // Add module export
+    if (moduleName) {
+      output += `\nexport const ${moduleName} = {\n`;
+      output += `  name: "${exportName}",\n`;
+      output += `  fields: ${JSON.stringify(Object.keys(schema), null, 2)}\n`;
+      output += "};\n";
     }
 
-    /**
-     * Generate JSDoc for a single field
-     */
-    private static generateFieldJSDoc(fieldName: string, fieldType: any): string {
-        if (typeof fieldType === "string") {
-            const cleanType = fieldType.replace("?", "");
-            const isOptional = fieldType.includes("?");
-
-            let description = `${fieldName} field`;
-
-            // Add type-specific descriptions
-            if (cleanType === "email") description = "Email address";
-            else if (cleanType === "url") description = "URL address";
-            else if (cleanType === "uuid") description = "Unique identifier";
-            else if (cleanType === "date") description = "Date and time";
-            else if (cleanType === "positive") description = "Positive number";
-            else if (cleanType.startsWith("string")) description = "Text value";
-            else if (cleanType.includes("[]")) description = "Array of values";
-
-            let jsdoc = `/**\n * ${description}`;
-
-            if (isOptional) {
-                jsdoc += "\n * @optional";
-            }
-
-            // Add constraints info
-            if (cleanType.includes("(")) {
-                const match = cleanType.match(/\(([^)]+)\)/);
-                if (match) {
-                    jsdoc += `\n * @constraints ${match[1]}`;
-                }
-            }
-
-            jsdoc += "\n */";
-            return jsdoc;
+    return output;
+  }
+
+  /**
+   * Generate JSDoc comments for schema fields
+   */
+  static generateJSDoc(schema: SchemaInterface): Record<string, string> {
+    const docs: Record<string, string> = {};
+
+    Object.entries(schema).forEach(([fieldName, fieldType]) => {
+      docs[fieldName] = this.generateFieldJSDoc(fieldName, fieldType);
+    });
+
+    return docs;
+  }
+
+  /**
+   * Generate JSDoc for a single field
+   */
+  private static generateFieldJSDoc(fieldName: string, fieldType: any): string {
+    if (typeof fieldType === "string") {
+      const cleanType = fieldType.replace("?", "");
+      const isOptional = fieldType.includes("?");
+
+      let description = `${fieldName} field`;
+
+      // Add type-specific descriptions
+      if (cleanType === "email") description = "Email address";
+      else if (cleanType === "url") description = "URL address";
+      else if (cleanType === "uuid") description = "Unique identifier";
+      else if (cleanType === "date") description = "Date and time";
+      else if (cleanType === "positive") description = "Positive number";
+      else if (cleanType.startsWith("string")) description = "Text value";
+      else if (cleanType.includes("[]")) description = "Array of values";
+
+      let jsdoc = `/**\n * ${description}`;
+
+      if (isOptional) {
+        jsdoc += "\n * @optional";
+      }
+
+      // Add constraints info
+      if (cleanType.includes("(")) {
+        const match = cleanType.match(/\(([^)]+)\)/);
+        if (match) {
+          jsdoc += `\n * @constraints ${match[1]}`;
         }
+      }
 
-        return `/**\n * ${fieldName} field\n */`;
+      jsdoc += "\n */";
+      return jsdoc;
     }
+
+    return `/**\n * ${fieldName} field\n */`;
+  }
 }
 
 /**
  * Type definitions
  */
 export interface TypeScriptOptions {
-    exportName?: string;
-    namespace?: string;
-    exportType?: "interface" | "type";
+  exportName?: string;
+  namespace?: string;
+  exportType?: "interface" | "type";
 }
 
 export interface ModuleOptions {
-    moduleName?: string;
-    exportName?: string;
-    includeUtilities?: boolean;
-    includeValidation?: boolean;
-    header?: string;
+  moduleName?: string;
+  exportName?: string;
+  includeUtilities?: boolean;
+  includeValidation?: boolean;
+  header?: string;
 }
 
-export {TypeScriptGenerator as TSGenerator}
+export { TypeScriptGenerator as TSGenerator };