oa_forge_emitter_angular/

lib.rs

use std::fmt::Write;

use oa_forge_ir::*;

/// Emit an Angular `@Injectable` service using `HttpClient`.
pub fn emit(api: &ApiSpec, out: &mut String) -> Result<(), std::fmt::Error> {
    writeln!(out, "// Generated by oa-forge. Do not edit.")?;
    writeln!(out)?;
    writeln!(out, "import {{ Injectable }} from '@angular/core';")?;
    writeln!(
        out,
        "import {{ HttpClient, HttpParams }} from '@angular/common/http';"
    )?;
    writeln!(out, "import type {{ Observable }} from 'rxjs';")?;

    emit_type_imports(api, out)?;
    writeln!(out)?;

    writeln!(out, "@Injectable({{ providedIn: 'root' }})")?;
    writeln!(out, "export class ApiService {{")?;
    writeln!(out, "  constructor(private http: HttpClient) {{}}")?;
    writeln!(out)?;

    for endpoint in &api.endpoints {
        emit_method(endpoint, out)?;
        writeln!(out)?;
    }

    writeln!(out, "}}")?;

    Ok(())
}

fn emit_type_imports(api: &ApiSpec, out: &mut String) -> Result<(), std::fmt::Error> {
    let mut imports = Vec::new();

    for endpoint in &api.endpoints {
        let id = &endpoint.operation_id;
        let has_path = endpoint
            .parameters
            .iter()
            .any(|p| p.location == ParamLocation::Path);
        let has_query = endpoint
            .parameters
            .iter()
            .any(|p| p.location == ParamLocation::Query);

        if has_path {
            imports.push(format!("{id}PathParams"));
        }
        if has_query {
            imports.push(format!("{id}QueryParams"));
        }
        if endpoint.response.is_some() && endpoint.response_type == ResponseType::Json {
            imports.push(format!("{id}Response"));
        }
        if endpoint.request_body.is_some() {
            imports.push(format!("{id}Body"));
        }
    }

    if !imports.is_empty() {
        writeln!(
            out,
            "import type {{ {} }} from './types.gen';",
            imports.join(", ")
        )?;
    }

    Ok(())
}

fn emit_method(endpoint: &Endpoint, out: &mut String) -> Result<(), std::fmt::Error> {
    let id = &endpoint.operation_id;
    let method = match endpoint.method {
        HttpMethod::Get => "get",
        HttpMethod::Post => "post",
        HttpMethod::Put => "put",
        HttpMethod::Patch => "patch",
        HttpMethod::Delete => "delete",
    };

    let has_path = endpoint
        .parameters
        .iter()
        .any(|p| p.location == ParamLocation::Path);
    let has_query = endpoint
        .parameters
        .iter()
        .any(|p| p.location == ParamLocation::Query);
    let has_body = endpoint.request_body.is_some();

    let mut params = Vec::new();
    if has_path {
        params.push(format!("pathParams: {id}PathParams"));
    }
    if has_query {
        params.push(format!("queryParams?: {id}QueryParams"));
    }
    if has_body {
        params.push(format!("body: {id}Body"));
    }

    let return_type = match endpoint.response_type {
        ResponseType::Json if endpoint.response.is_some() => format!("{id}Response"),
        ResponseType::Text => "string".to_string(),
        ResponseType::Blob => "Blob".to_string(),
        _ => "void".to_string(),
    };

    let url = build_url_template(&endpoint.path);

    writeln!(
        out,
        "  {id}({params}): Observable<{return_type}> {{",
        params = params.join(", ")
    )?;

    // Build HttpParams for query
    if has_query {
        writeln!(out, "    let params = new HttpParams();")?;
        writeln!(out, "    if (queryParams) {{")?;
        writeln!(
            out,
            "      for (const [key, value] of Object.entries(queryParams)) {{"
        )?;
        writeln!(
            out,
            "        if (value !== undefined) params = params.set(key, String(value));"
        )?;
        writeln!(out, "      }}")?;
        writeln!(out, "    }}")?;
    }

    let options = match endpoint.response_type {
        ResponseType::Text => {
            if has_query {
                "{{ params, responseType: 'text' as const }}"
            } else {
                "{{ responseType: 'text' as const }}"
            }
        }
        ResponseType::Blob => {
            if has_query {
                "{{ params, responseType: 'blob' as const }}"
            } else {
                "{{ responseType: 'blob' as const }}"
            }
        }
        _ => {
            if has_query {
                "{{ params }}"
            } else {
                ""
            }
        }
    };

    if has_body {
        if options.is_empty() {
            writeln!(
                out,
                "    return this.http.{method}<{return_type}>(`{url}`, body);"
            )?;
        } else {
            writeln!(
                out,
                "    return this.http.{method}<{return_type}>(`{url}`, body, {options});"
            )?;
        }
    } else if matches!(
        endpoint.method,
        HttpMethod::Post | HttpMethod::Put | HttpMethod::Patch
    ) {
        if options.is_empty() {
            writeln!(
                out,
                "    return this.http.{method}<{return_type}>(`{url}`, null);"
            )?;
        } else {
            writeln!(
                out,
                "    return this.http.{method}<{return_type}>(`{url}`, null, {options});"
            )?;
        }
    } else if options.is_empty() {
        writeln!(
            out,
            "    return this.http.{method}<{return_type}>(`{url}`);"
        )?;
    } else {
        writeln!(
            out,
            "    return this.http.{method}<{return_type}>(`{url}`, {options});"
        )?;
    }

    writeln!(out, "  }}")?;

    Ok(())
}

fn build_url_template(path: &str) -> String {
    let mut result = String::new();
    let mut chars = path.chars().peekable();

    while let Some(c) = chars.next() {
        if c == '{' {
            let param_name: String = chars.by_ref().take_while(|&c| c != '}').collect();
            result.push_str(&format!("${{pathParams.{param_name}}}"));
        } else {
            result.push(c);
        }
    }

    result
}