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, HttpHeaders }} from '@angular/common/http';"
    )?;
    writeln!(out, "import type {{ Observable }} from 'rxjs';")?;

    let imports = collect_type_imports(api);
    if !imports.is_empty() {
        writeln!(
            out,
            "import type {{ {} }} from './types.gen';",
            imports.join(", ")
        )?;
    }
    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_method(endpoint: &Endpoint, out: &mut String) -> Result<(), std::fmt::Error> {
    let id = &endpoint.operation_id;
    let method = endpoint.method.as_lower();

    let has_path = endpoint.has_params(&ParamLocation::Path);
    let has_query = endpoint.has_params(&ParamLocation::Query);
    let has_header = endpoint.has_params(&ParamLocation::Header);
    let has_cookie = endpoint.has_params(&ParamLocation::Cookie);
    let has_body = endpoint.request_body.is_some();
    let has_headers = has_header || has_cookie;

    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_header {
        params.push(format!("headerParams?: {id}HeaderParams"));
    }
    if has_cookie {
        params.push(format!("cookieParams?: {id}CookieParams"));
    }
    if has_body {
        params.push(format!("body: {id}Body"));
    }

    let return_type = endpoint.return_type_ts();
    let url = path_to_template_literal(&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 (Array.isArray(value)) {{")?;
        writeln!(
            out,
            "          for (const v of value) params = params.append(key, String(v));"
        )?;
        writeln!(out, "        }} else if (value !== undefined) {{")?;
        writeln!(out, "          params = params.set(key, String(value));")?;
        writeln!(out, "        }}")?;
        writeln!(out, "      }}")?;
        writeln!(out, "    }}")?;
    }

    // Build HttpHeaders for header/cookie params
    if has_headers {
        writeln!(out, "    let headers = new HttpHeaders();")?;
    }
    if has_header {
        writeln!(out, "    if (headerParams) {{")?;
        writeln!(
            out,
            "      for (const [key, value] of Object.entries(headerParams)) {{"
        )?;
        writeln!(
            out,
            "        if (value !== undefined) headers = headers.set(key, String(value));"
        )?;
        writeln!(out, "      }}")?;
        writeln!(out, "    }}")?;
    }
    if has_cookie {
        writeln!(out, "    if (cookieParams) {{")?;
        writeln!(
            out,
            "      const cookie = Object.entries(cookieParams).filter(([, v]) => v !== undefined).map(([k, v]) => `${{k}}=${{v}}`).join('; ');"
        )?;
        writeln!(out, "      headers = headers.set('Cookie', cookie);")?;
        writeln!(out, "    }}")?;
    }

    // Build options object
    let options = build_options(has_query, has_headers, endpoint.response_type.clone());

    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_options(has_query: bool, has_headers: bool, response_type: ResponseType) -> String {
    let mut parts = Vec::new();

    if has_query {
        parts.push("params".to_string());
    }
    if has_headers {
        parts.push("headers".to_string());
    }

    match response_type {
        ResponseType::Text => parts.push("responseType: 'text' as const".to_string()),
        ResponseType::Blob => parts.push("responseType: 'blob' as const".to_string()),
        _ => {}
    }

    if parts.is_empty() {
        String::new()
    } else {
        format!("{{ {} }}", parts.join(", "))
    }
}