metaxy_cli/codegen/

typescript.rs

use super::common::GENERATED_HEADER;
use crate::config::FieldNaming;
use crate::model::{
    EnumDef, EnumTagging, EnumVariant, FieldDef, Manifest, Procedure, ProcedureKind, RenameRule,
    RustType, StructDef, VariantKind,
};

/// Converts a `RustType` into its TypeScript equivalent.
///
/// Mapping rules:
/// - Rust primitives (`String`, `str`, `char`) → `string`
/// - Numeric types (`i8`..`i128`, `u8`..`u128`, `f32`, `f64`, `isize`, `usize`) → `number`
/// - `bool` → `boolean`
/// - `()` → `void`
/// - `Vec<T>`, `Array<T>`, `HashSet<T>`, `BTreeSet<T>` → `T[]`
/// - `Option<T>` → `T | null`
/// - `HashMap<K, V>`, `BTreeMap<K, V>` → `Record<K, V>`
/// - `Box<T>`, `Arc<T>`, `Rc<T>`, `Cow<T>` → `T` (transparent wrappers)
/// - `tuple(A, B, ...)` → `[A, B, ...]`
/// - Everything else (user-defined structs) → kept as-is
pub fn rust_type_to_ts(ty: &RustType) -> String {
    match ty.base_name() {
        // Unit type
        "()" => "void".to_string(),

        // String types
        "String" | "str" | "char" | "&str" => "string".to_string(),

        // Boolean
        "bool" => "boolean".to_string(),

        // Numeric types
        "i8" | "i16" | "i32" | "i64" | "i128" | "u8" | "u16" | "u32" | "u64" | "u128" | "f32"
        | "f64" | "isize" | "usize" => "number".to_string(),

        // Vec / Array / Set types → T[]
        "Vec" | "Array" | "HashSet" | "BTreeSet" => {
            let inner = ty
                .generics
                .first()
                .map(rust_type_to_ts)
                .unwrap_or_else(|| "unknown".to_string());
            // Wrap union types in parens for correct precedence: `(A | B)[]`
            if inner.contains(" | ") {
                format!("({inner})[]")
            } else {
                format!("{inner}[]")
            }
        }

        // Option<T> → T | null
        "Option" => {
            let inner = ty
                .generics
                .first()
                .map(rust_type_to_ts)
                .unwrap_or_else(|| "unknown".to_string());
            format!("{inner} | null")
        }

        // HashMap / BTreeMap → Record<K, V>
        "HashMap" | "BTreeMap" => {
            let key = ty
                .generics
                .first()
                .map(rust_type_to_ts)
                .unwrap_or_else(|| "string".to_string());
            let value = ty
                .generics
                .get(1)
                .map(rust_type_to_ts)
                .unwrap_or_else(|| "unknown".to_string());
            format!("Record<{key}, {value}>")
        }

        // Smart pointers / wrappers → unwrap to inner type
        "Box" | "Arc" | "Rc" | "Cow" => ty
            .generics
            .first()
            .map(rust_type_to_ts)
            .unwrap_or_else(|| "unknown".to_string()),

        // Tuple → [A, B, ...]
        "tuple" => {
            let elems: Vec<String> = ty.generics.iter().map(rust_type_to_ts).collect();
            format!("[{}]", elems.join(", "))
        }

        // User-defined types or unknown — pass through, preserving generics
        other => {
            if ty.generics.is_empty() {
                other.to_string()
            } else {
                let params: Vec<String> = ty.generics.iter().map(rust_type_to_ts).collect();
                format!("{other}<{}>", params.join(", "))
            }
        }
    }
}

/// Emits a JSDoc comment block from a doc string.
pub fn emit_jsdoc(doc: &str, indent: &str, out: &mut String) {
    if !doc.contains('\n') {
        emit!(out, "{indent}/** {doc} */");
    } else {
        emit!(out, "{indent}/**");
        for line in doc.lines() {
            emit!(out, "{indent} * {line}");
        }
        emit!(out, "{indent} */");
    }
}

/// Converts a snake_case string to camelCase.
pub fn to_camel_case(s: &str) -> String {
    let mut segments = s.split('_');
    let mut result = segments.next().unwrap_or_default().to_lowercase();
    for segment in segments {
        let mut chars = segment.chars();
        if let Some(first) = chars.next() {
            result.extend(first.to_uppercase());
            result.push_str(&chars.as_str().to_lowercase());
        }
    }
    result
}

/// Transforms a field name according to the naming strategy.
fn transform_field_name(name: &str, naming: FieldNaming) -> String {
    match naming {
        FieldNaming::Preserve => name.to_string(),
        FieldNaming::CamelCase => to_camel_case(name),
    }
}

/// Resolves the final output name for a struct/variant field.
///
/// Priority: field `rename` > container `rename_all` > config `field_naming` > original name.
fn resolve_field_name(
    field: &FieldDef,
    container_rename_all: Option<RenameRule>,
    config_naming: FieldNaming,
) -> String {
    if let Some(rename) = &field.rename {
        return rename.clone();
    }
    if let Some(rule) = container_rename_all {
        return rule.apply(&field.name);
    }
    transform_field_name(&field.name, config_naming)
}

/// Resolves the final output name for an enum variant.
///
/// Priority: variant `rename` > container `rename_all` > original name.
fn resolve_variant_name(variant: &EnumVariant, container_rename_all: Option<RenameRule>) -> String {
    if let Some(rename) = &variant.rename {
        return rename.clone();
    }
    if let Some(rule) = container_rename_all {
        return rule.apply(&variant.name);
    }
    variant.name.clone()
}

/// Returns the inner type of `Option<T>`, or `None` if not an Option.
fn option_inner_type(ty: &RustType) -> Option<&RustType> {
    if ty.name == "Option" {
        ty.generics.first()
    } else {
        None
    }
}

/// Renders a single struct/variant field as `name: T` or `name?: T | null`.
///
/// When a field has `#[serde(default)]` and is `Option<T>`, it becomes optional
/// (`name?: T | null`). Otherwise it renders as a required field (`name: T`).
fn render_field_str(
    field: &FieldDef,
    container_rename_all: Option<RenameRule>,
    config_naming: FieldNaming,
) -> String {
    let name = resolve_field_name(field, container_rename_all, config_naming);
    if field.has_default
        && let Some(inner) = option_inner_type(&field.ty)
    {
        format!("{}?: {} | null", name, rust_type_to_ts(inner))
    } else {
        format!("{}: {}", name, rust_type_to_ts(&field.ty))
    }
}

/// Splits fields into regular fields and flattened type names.
///
/// - Skipped fields are omitted entirely.
/// - Flattened fields contribute their type name to the intersection list.
/// - Regular fields are rendered as `name: T` strings.
fn render_struct_body(
    fields: &[FieldDef],
    rename_all: Option<RenameRule>,
    field_naming: FieldNaming,
) -> (Vec<String>, Vec<String>) {
    let mut regular = Vec::new();
    let mut flattened = Vec::new();
    for f in fields {
        if f.skip {
            continue;
        }
        if f.flatten {
            flattened.push(rust_type_to_ts(&f.ty));
        } else {
            regular.push(render_field_str(f, rename_all, field_naming));
        }
    }
    (regular, flattened)
}

/// Builds an inline `{ field; field }` object string, optionally intersected with
/// flattened types. Returns the combined expression.
fn build_object_with_flatten(regular: &[String], flattened: &[String]) -> String {
    let mut parts = Vec::new();
    if !regular.is_empty() {
        parts.push(format!("{{ {} }}", regular.join("; ")));
    }
    parts.extend(flattened.iter().cloned());
    parts.join(" & ")
}

/// Generates a TypeScript interface or type alias from a struct definition.
///
/// - Named structs → `export interface Name { ... }`
/// - Named structs with flatten → `export type Name = { ... } & Flattened;`
/// - Single-field tuple structs (newtypes) → `export type Name = inner;`
///   (with optional branded type when `branded_newtypes` is enabled)
/// - Multi-field tuple structs → `export type Name = [A, B, ...];`
fn generate_interface(
    s: &StructDef,
    preserve_docs: bool,
    field_naming: FieldNaming,
    branded_newtypes: bool,
    out: &mut String,
) {
    if preserve_docs && let Some(doc) = &s.docs {
        emit_jsdoc(doc, "", out);
    }
    let generic_params = format_generic_params(&s.generics);

    // Tuple struct handling
    if !s.tuple_fields.is_empty() {
        if s.tuple_fields.len() == 1 {
            // Newtype: single-field tuple struct
            let inner = rust_type_to_ts(&s.tuple_fields[0]);
            if branded_newtypes {
                emit!(
                    out,
                    "export type {}{generic_params} = {inner} & {{ readonly __brand: \"{}\" }};",
                    s.name,
                    s.name
                );
            } else {
                emit!(out, "export type {}{generic_params} = {inner};", s.name);
            }
        } else {
            // Multi-field tuple struct → TS tuple
            let elems: Vec<String> = s.tuple_fields.iter().map(rust_type_to_ts).collect();
            emit!(
                out,
                "export type {}{generic_params} = [{}];",
                s.name,
                elems.join(", ")
            );
        }
        return;
    }

    let (regular, flattened) = render_struct_body(&s.fields, s.rename_all, field_naming);

    if flattened.is_empty() {
        // No flatten → standard interface
        emit!(out, "export interface {}{generic_params} {{", s.name);
        for r in &regular {
            emit!(out, "  {r};");
        }
        emit!(out, "}}");
    } else {
        // Has flatten → export type with intersection
        let body = build_object_with_flatten(&regular, &flattened);
        emit!(out, "export type {}{generic_params} = {body};", s.name);
    }
}

/// Generates a TypeScript type from an enum definition.
///
/// Dispatches to the appropriate strategy based on `e.tagging`:
/// - `External` (default): serde's externally tagged representation
/// - `Internal { tag }`: internally tagged (`#[serde(tag = "...")]`)
/// - `Adjacent { tag, content }`: adjacently tagged (`#[serde(tag = "...", content = "...")]`)
/// - `Untagged`: no tag wrapper (`#[serde(untagged)]`)
fn generate_enum_type(
    e: &EnumDef,
    preserve_docs: bool,
    field_naming: FieldNaming,
    out: &mut String,
) {
    if preserve_docs && let Some(doc) = &e.docs {
        emit_jsdoc(doc, "", out);
    }

    match &e.tagging {
        EnumTagging::External => generate_enum_external(e, field_naming, out),
        EnumTagging::Internal { tag } => generate_enum_internal(e, tag, field_naming, out),
        EnumTagging::Adjacent { tag, content } => {
            generate_enum_adjacent(e, tag, content, field_naming, out);
        }
        EnumTagging::Untagged => generate_enum_untagged(e, field_naming, out),
    }
}

/// Externally tagged (serde default): `{ "Variant": data }` or string literal for unit variants.
fn generate_enum_external(e: &EnumDef, field_naming: FieldNaming, out: &mut String) {
    let generic_params = format_generic_params(&e.generics);
    let all_unit = e
        .variants
        .iter()
        .all(|v| matches!(v.kind, VariantKind::Unit));

    if all_unit {
        let variants: Vec<String> = e
            .variants
            .iter()
            .map(|v| {
                let name = resolve_variant_name(v, e.rename_all);
                format!("\"{name}\"")
            })
            .collect();
        if variants.is_empty() {
            emit!(out, "export type {}{generic_params} = never;", e.name);
        } else {
            emit!(
                out,
                "export type {}{generic_params} = {};",
                e.name,
                variants.join(" | ")
            );
        }
    } else {
        let mut variant_types: Vec<String> = Vec::new();

        for v in &e.variants {
            let variant_name = resolve_variant_name(v, e.rename_all);
            match &v.kind {
                VariantKind::Unit => {
                    variant_types.push(format!("\"{variant_name}\""));
                }
                VariantKind::Tuple(types) => {
                    let inner = if types.len() == 1 {
                        rust_type_to_ts(&types[0])
                    } else {
                        let elems: Vec<String> = types.iter().map(rust_type_to_ts).collect();
                        format!("[{}]", elems.join(", "))
                    };
                    variant_types.push(format!("{{ {variant_name}: {inner} }}"));
                }
                VariantKind::Struct(fields) => {
                    let (regular, flattened) =
                        render_struct_body(fields, e.rename_all, field_naming);
                    let inner = build_object_with_flatten(&regular, &flattened);
                    variant_types.push(format!("{{ {variant_name}: {inner} }}"));
                }
            }
        }

        emit!(
            out,
            "export type {}{generic_params} = {};",
            e.name,
            variant_types.join(" | ")
        );
    }
}

/// Internally tagged: `{ "tag": "Variant", ...fields }`.
///
/// - Unit → `{ tag: "Name" }`
/// - Struct → `{ tag: "Name"; field: T; ... }`
/// - Tuple(1) → `{ tag: "Name" } & InnerType` (newtype wrapping struct)
/// - Tuple(n>1) → skipped (serde rejects multi-field tuples in internally tagged)
fn generate_enum_internal(e: &EnumDef, tag: &str, field_naming: FieldNaming, out: &mut String) {
    let generic_params = format_generic_params(&e.generics);
    if e.variants.is_empty() {
        emit!(out, "export type {}{generic_params} = never;", e.name);
        return;
    }

    let mut variant_types: Vec<String> = Vec::new();

    for v in &e.variants {
        let variant_name = resolve_variant_name(v, e.rename_all);
        match &v.kind {
            VariantKind::Unit => {
                variant_types.push(format!("{{ {tag}: \"{variant_name}\" }}"));
            }
            VariantKind::Struct(fields) => {
                let (regular, flattened) = render_struct_body(fields, e.rename_all, field_naming);
                let mut parts = vec![format!("{tag}: \"{variant_name}\"")];
                parts.extend(regular);
                let obj = format!("{{ {} }}", parts.join("; "));
                if flattened.is_empty() {
                    variant_types.push(obj);
                } else {
                    let all: Vec<String> = std::iter::once(obj).chain(flattened).collect();
                    variant_types.push(all.join(" & "));
                }
            }
            VariantKind::Tuple(types) => {
                if types.len() == 1 {
                    let inner = rust_type_to_ts(&types[0]);
                    variant_types.push(format!("{{ {tag}: \"{variant_name}\" }} & {inner}"));
                }
                // Multi-field tuples are rejected by serde for internal tagging — skip
            }
        }
    }

    if variant_types.is_empty() {
        emit!(out, "export type {}{generic_params} = never;", e.name);
    } else {
        emit!(
            out,
            "export type {}{generic_params} = {};",
            e.name,
            variant_types.join(" | ")
        );
    }
}

/// Adjacently tagged: `{ "tag": "Variant", "content": data }`.
///
/// - Unit → `{ tag: "Name" }` (no content key)
/// - Tuple(1) → `{ tag: "Name"; content: T }`
/// - Tuple(n) → `{ tag: "Name"; content: [A, B, ...] }`
/// - Struct → `{ tag: "Name"; content: { field: T; ... } }`
fn generate_enum_adjacent(
    e: &EnumDef,
    tag: &str,
    content: &str,
    field_naming: FieldNaming,
    out: &mut String,
) {
    let generic_params = format_generic_params(&e.generics);
    if e.variants.is_empty() {
        emit!(out, "export type {}{generic_params} = never;", e.name);
        return;
    }

    let mut variant_types: Vec<String> = Vec::new();

    for v in &e.variants {
        let variant_name = resolve_variant_name(v, e.rename_all);
        match &v.kind {
            VariantKind::Unit => {
                variant_types.push(format!("{{ {tag}: \"{variant_name}\" }}"));
            }
            VariantKind::Tuple(types) => {
                let inner = if types.len() == 1 {
                    rust_type_to_ts(&types[0])
                } else {
                    let elems: Vec<String> = types.iter().map(rust_type_to_ts).collect();
                    format!("[{}]", elems.join(", "))
                };
                variant_types.push(format!(
                    "{{ {tag}: \"{variant_name}\"; {content}: {inner} }}"
                ));
            }
            VariantKind::Struct(fields) => {
                let (regular, flattened) = render_struct_body(fields, e.rename_all, field_naming);
                let inner = build_object_with_flatten(&regular, &flattened);
                variant_types.push(format!(
                    "{{ {tag}: \"{variant_name}\"; {content}: {inner} }}"
                ));
            }
        }
    }

    emit!(
        out,
        "export type {}{generic_params} = {};",
        e.name,
        variant_types.join(" | ")
    );
}

/// Untagged: no wrapper, just the data.
///
/// - Unit → `null`
/// - Tuple(1) → `T`
/// - Tuple(n) → `[A, B, ...]`
/// - Struct → `{ field: T; ... }`
/// - Empty enum → `never`
fn generate_enum_untagged(e: &EnumDef, field_naming: FieldNaming, out: &mut String) {
    let generic_params = format_generic_params(&e.generics);
    if e.variants.is_empty() {
        emit!(out, "export type {}{generic_params} = never;", e.name);
        return;
    }

    let mut variant_types: Vec<String> = Vec::new();

    for v in &e.variants {
        match &v.kind {
            VariantKind::Unit => {
                variant_types.push("null".to_string());
            }
            VariantKind::Tuple(types) => {
                if types.len() == 1 {
                    variant_types.push(rust_type_to_ts(&types[0]));
                } else {
                    let elems: Vec<String> = types.iter().map(rust_type_to_ts).collect();
                    variant_types.push(format!("[{}]", elems.join(", ")));
                }
            }
            VariantKind::Struct(fields) => {
                let (regular, flattened) = render_struct_body(fields, e.rename_all, field_naming);
                let inner = build_object_with_flatten(&regular, &flattened);
                variant_types.push(inner);
            }
        }
    }

    emit!(
        out,
        "export type {}{generic_params} = {};",
        e.name,
        variant_types.join(" | ")
    );
}

/// Formats generic type parameters for TypeScript output (e.g. `<T>`, `<A, B>`).
///
/// Returns an empty string when there are no generic parameters.
fn format_generic_params(generics: &[String]) -> String {
    if generics.is_empty() {
        String::new()
    } else {
        format!("<{}>", generics.join(", "))
    }
}

/// Generates the `Procedures` type that maps procedure names to their input/output types,
/// grouped by kind (queries / mutations).
fn generate_procedures_type(procedures: &[Procedure], preserve_docs: bool, out: &mut String) {
    let (queries, mutations): (Vec<_>, Vec<_>) = procedures
        .iter()
        .partition(|p| p.kind == ProcedureKind::Query);

    emit!(out, "export type Procedures = {{");

    // Queries
    emit!(out, "  queries: {{");
    for proc in &queries {
        if preserve_docs && let Some(doc) = &proc.docs {
            emit_jsdoc(doc, "    ", out);
        }
        let input = proc
            .input
            .as_ref()
            .map(rust_type_to_ts)
            .unwrap_or_else(|| "void".to_string());
        let output = proc
            .output
            .as_ref()
            .map(rust_type_to_ts)
            .unwrap_or_else(|| "void".to_string());
        emit!(
            out,
            "    {}: {{ input: {input}; output: {output} }};",
            proc.name
        );
    }
    emit!(out, "  }};");

    // Mutations
    emit!(out, "  mutations: {{");
    for proc in &mutations {
        if preserve_docs && let Some(doc) = &proc.docs {
            emit_jsdoc(doc, "    ", out);
        }
        let input = proc
            .input
            .as_ref()
            .map(rust_type_to_ts)
            .unwrap_or_else(|| "void".to_string());
        let output = proc
            .output
            .as_ref()
            .map(rust_type_to_ts)
            .unwrap_or_else(|| "void".to_string());
        emit!(
            out,
            "    {}: {{ input: {input}; output: {output} }};",
            proc.name
        );
    }
    emit!(out, "  }};");

    emit!(out, "}};");
}

/// Generates the complete `rpc-types.ts` file content from a manifest.
///
/// The output includes:
/// 1. Auto-generation header
/// 2. TypeScript interfaces for all referenced structs
/// 3. The `Procedures` type mapping
pub fn generate_types_file(
    manifest: &Manifest,
    preserve_docs: bool,
    field_naming: FieldNaming,
    branded_newtypes: bool,
) -> String {
    let mut out = String::with_capacity(1024);

    // Header
    out.push_str(GENERATED_HEADER);
    out.push('\n');

    // Emit all structs discovered in the scanned files.
    for s in &manifest.structs {
        generate_interface(s, preserve_docs, field_naming, branded_newtypes, &mut out);
        out.push('\n');
    }

    // Emit all enums discovered in the scanned files.
    for e in &manifest.enums {
        generate_enum_type(e, preserve_docs, field_naming, &mut out);
        out.push('\n');
    }

    // Generate the Procedures type
    generate_procedures_type(&manifest.procedures, preserve_docs, &mut out);

    out
}