prax_typegen/

typescript.rs

//! TypeScript interface generator.

use convert_case::{Case, Casing};
use prax_schema::{CompositeType, Enum, Field, FieldType, Model, Schema, View};

use crate::mapping::TypeMapper;

/// Generates TypeScript interfaces from a Prax schema.
pub struct InterfaceGenerator;

impl InterfaceGenerator {
    /// Generate all TypeScript interfaces for the given schema.
    pub fn generate(schema: &Schema) -> String {
        let mut out = String::with_capacity(4096);
        out.push_str("// Auto-generated by prax-typegen. Do not edit.\n\n");

        for (_, enum_def) in &schema.enums {
            Self::write_enum(&mut out, enum_def);
            out.push('\n');
        }

        for (_, composite) in &schema.types {
            Self::write_composite(&mut out, composite, schema);
            out.push('\n');
        }

        for (_, model) in &schema.models {
            Self::write_model(&mut out, model, schema);
            out.push('\n');
        }

        for (_, view) in &schema.views {
            Self::write_view(&mut out, view, schema);
            out.push('\n');
        }

        out
    }

    fn write_enum(out: &mut String, enum_def: &Enum) {
        if let Some(doc) = &enum_def.documentation {
            write_jsdoc(out, &doc.text, 0);
        }
        out.push_str(&format!("export enum {} {{\n", enum_def.name()));
        for variant in &enum_def.variants {
            let db_val = variant.db_value();
            out.push_str(&format!("  {} = '{}',\n", variant.name(), db_val));
        }
        out.push_str("}\n");
    }

    fn write_model(out: &mut String, model: &Model, schema: &Schema) {
        if let Some(doc) = &model.documentation {
            write_jsdoc(out, &doc.text, 0);
        }
        out.push_str(&format!("export interface {} {{\n", model.name()));

        for (_, field) in &model.fields {
            if field.is_relation() {
                Self::write_relation_field(out, field, schema);
            } else {
                Self::write_field(out, field, schema);
            }
        }

        out.push_str("}\n");

        Self::write_create_input(out, model, schema);
        Self::write_update_input(out, model, schema);
    }

    fn write_view(out: &mut String, view: &View, schema: &Schema) {
        if let Some(doc) = &view.documentation {
            write_jsdoc(out, &doc.text, 0);
        }
        out.push_str(&format!("export interface {} {{\n", view.name()));

        for (_, field) in &view.fields {
            Self::write_field(out, field, schema);
        }

        out.push_str("}\n");
    }

    fn write_composite(out: &mut String, composite: &CompositeType, schema: &Schema) {
        if let Some(doc) = &composite.documentation {
            write_jsdoc(out, &doc.text, 0);
        }
        out.push_str(&format!("export interface {} {{\n", composite.name()));

        for (_, field) in &composite.fields {
            Self::write_field(out, field, schema);
        }

        out.push_str("}\n");
    }

    fn write_field(out: &mut String, field: &Field, schema: &Schema) {
        let name = field.name().to_case(Case::Camel);
        let optional = field.modifier.is_optional();
        let ts_type = resolve_ts_type(field, schema);

        let opt_mark = if optional { "?" } else { "" };
        out.push_str(&format!("  {name}{opt_mark}: {ts_type};\n"));
    }

    fn write_relation_field(out: &mut String, field: &Field, _schema: &Schema) {
        let name = field.name().to_case(Case::Camel);
        let type_name = field.field_type.type_name();
        let optional = field.modifier.is_optional();
        let is_list = field.modifier.is_list();

        let ts = if is_list {
            format!("{type_name}[]")
        } else {
            type_name.to_string()
        };

        let opt_mark = if optional { "?" } else { "" };
        out.push_str(&format!("  {name}{opt_mark}: {ts};\n"));
    }

    fn write_create_input(out: &mut String, model: &Model, schema: &Schema) {
        out.push_str(&format!(
            "\nexport interface {}CreateInput {{\n",
            model.name()
        ));
        for (_, field) in &model.fields {
            if field.is_relation() {
                continue;
            }
            let attrs = field.extract_attributes();
            if attrs.is_auto || attrs.is_updated_at {
                continue;
            }

            let name = field.name().to_case(Case::Camel);
            let ts_type = resolve_ts_type(field, schema);
            let optional = field.modifier.is_optional() || attrs.default.is_some() || attrs.is_id;
            let opt_mark = if optional { "?" } else { "" };
            out.push_str(&format!("  {name}{opt_mark}: {ts_type};\n"));
        }
        out.push_str("}\n");
    }

    fn write_update_input(out: &mut String, model: &Model, schema: &Schema) {
        out.push_str(&format!(
            "\nexport interface {}UpdateInput {{\n",
            model.name()
        ));
        for (_, field) in &model.fields {
            if field.is_relation() {
                continue;
            }
            let attrs = field.extract_attributes();
            if attrs.is_auto || attrs.is_updated_at {
                continue;
            }

            let name = field.name().to_case(Case::Camel);
            let ts_type = resolve_ts_type(field, schema);
            out.push_str(&format!("  {name}?: {ts_type};\n"));
        }
        out.push_str("}\n");
    }
}

/// Resolve a field to its TypeScript type string.
fn resolve_ts_type(field: &Field, _schema: &Schema) -> String {
    let base = match &field.field_type {
        FieldType::Scalar(s) => TypeMapper::ts_type(s).to_string(),
        FieldType::Enum(name) => name.to_string(),
        FieldType::Model(name) => name.to_string(),
        FieldType::Composite(name) => name.to_string(),
        FieldType::Unsupported(_) => "unknown".to_string(),
    };

    if field.modifier.is_list() {
        format!("{base}[]")
    } else if field.modifier.is_optional() {
        format!("{base} | null")
    } else {
        base
    }
}

fn write_jsdoc(out: &mut String, text: &str, indent: usize) {
    let pad = " ".repeat(indent);
    out.push_str(&format!("{pad}/**\n"));
    for line in text.lines() {
        out.push_str(&format!("{pad} * {line}\n"));
    }
    out.push_str(&format!("{pad} */\n"));
}

#[cfg(test)]
mod tests {
    use super::*;
    use prax_schema::parse_schema;

    #[test]
    fn test_generate_simple_model() {
        let schema = parse_schema(
            r#"
            model User {
                id    Int    @id @auto
                email String @unique
                name  String?
            }
            "#,
        )
        .unwrap();

        let output = InterfaceGenerator::generate(&schema);
        assert!(output.contains("export interface User {"));
        assert!(output.contains("id: number;"));
        assert!(output.contains("email: string;"));
        assert!(output.contains("name?: string | null;"));
    }

    #[test]
    fn test_generate_enum() {
        let schema = parse_schema(
            r#"
            enum Role {
                User
                Admin
                Moderator
            }
            "#,
        )
        .unwrap();

        let output = InterfaceGenerator::generate(&schema);
        assert!(output.contains("export enum Role {"));
        assert!(output.contains("User = 'User',"));
        assert!(output.contains("Admin = 'Admin',"));
        assert!(output.contains("Moderator = 'Moderator',"));
    }

    #[test]
    fn test_generate_create_input() {
        let schema = parse_schema(
            r#"
            model Post {
                id      Int    @id @auto
                title   String
                content String?
            }
            "#,
        )
        .unwrap();

        let output = InterfaceGenerator::generate(&schema);
        assert!(output.contains("export interface PostCreateInput {"));
        assert!(output.contains("title: string;"));
        assert!(output.contains("content?: string | null;"));

        let create_block = output
            .split("export interface PostCreateInput {")
            .nth(1)
            .and_then(|s| s.split('}').next())
            .unwrap_or("");
        assert!(
            !create_block.contains("id"),
            "PostCreateInput should not contain auto-generated id field"
        );
    }

    #[test]
    fn test_generate_update_input_all_optional() {
        let schema = parse_schema(
            r#"
            model User {
                id   Int    @id @auto
                name String
            }
            "#,
        )
        .unwrap();

        let output = InterfaceGenerator::generate(&schema);
        assert!(output.contains("export interface UserUpdateInput {"));
        assert!(output.contains("name?: string;"));
    }

    #[test]
    fn test_generate_relation_fields() {
        let schema = parse_schema(
            r#"
            model User {
                id    Int    @id @auto
                posts Post[]
            }
            model Post {
                id       Int  @id @auto
                authorId Int
                author   User @relation(fields: [authorId], references: [id])
            }
            "#,
        )
        .unwrap();

        let output = InterfaceGenerator::generate(&schema);
        assert!(output.contains("posts: Post[];"));
        assert!(output.contains("author: User;"));
    }

    #[test]
    fn test_generate_composite_type() {
        let schema = parse_schema(
            r#"
            type Address {
                street  String
                city    String
                country String
            }
            "#,
        )
        .unwrap();

        let output = InterfaceGenerator::generate(&schema);
        assert!(output.contains("export interface Address {"));
        assert!(output.contains("street: string;"));
    }

    #[test]
    fn test_enum_field_reference() {
        let schema = parse_schema(
            r#"
            enum Status {
                Active
                Inactive
            }
            model User {
                id     Int    @id @auto
                status Status
            }
            "#,
        )
        .unwrap();

        let output = InterfaceGenerator::generate(&schema);
        assert!(output.contains("status: Status;"));
    }

    #[test]
    fn test_list_field() {
        let schema = parse_schema(
            r#"
            model User {
                id   Int      @id @auto
                tags String[]
            }
            "#,
        )
        .unwrap();

        let output = InterfaceGenerator::generate(&schema);
        assert!(output.contains("tags: string[];"));
    }

    #[test]
    fn test_datetime_types() {
        let schema = parse_schema(
            r#"
            model Event {
                id        Int      @id @auto
                startAt   DateTime
                eventDate Date
                eventTime Time
            }
            "#,
        )
        .unwrap();

        let output = InterfaceGenerator::generate(&schema);
        assert!(output.contains("startAt: Date;"));
        assert!(output.contains("eventDate: string;"));
        assert!(output.contains("eventTime: string;"));
    }
}