baobao_codegen_typescript/

generator.rs

//! TypeScript code generator using boune framework.

use std::{collections::HashSet, path::Path};

use baobao_codegen::{
    CodeBuilder, CommandInfo, CommandTree, ContextFieldInfo, GenerateResult, HandlerPaths,
    LanguageCodegen, PoolConfigInfo, PreviewFile, SqliteConfigInfo,
};
use baobao_core::{ContextFieldType, DatabaseType, GeneratedFile, to_camel_case, to_kebab_case};
use baobao_manifest::{Command, Language, Manifest};
use eyre::Result;

use crate::{
    ast::{ArrowFn, Import, JsObject},
    files::{
        BaoToml, CliTs, CommandTs, ContextTs, GitIgnore, HandlerTs, IndexTs, PackageJson, TsConfig,
    },
};

/// TypeScript code generator that produces boune-based CLI code for Bun.
pub struct Generator<'a> {
    schema: &'a Manifest,
}

impl LanguageCodegen for Generator<'_> {
    fn language(&self) -> &'static str {
        "typescript"
    }

    fn file_extension(&self) -> &'static str {
        "ts"
    }

    fn preview(&self) -> Vec<PreviewFile> {
        self.preview_files()
    }

    fn generate(&self, output_dir: &Path) -> Result<GenerateResult> {
        self.generate_files(output_dir)
    }
}

impl<'a> Generator<'a> {
    pub fn new(schema: &'a Manifest) -> Self {
        Self { schema }
    }

    /// Preview generated files without writing to disk.
    fn preview_files(&self) -> Vec<PreviewFile> {
        let mut files = Vec::new();

        // Collect context field info
        let context_fields = self.collect_context_fields();

        // context.ts
        files.push(PreviewFile {
            path: "src/context.ts".to_string(),
            content: ContextTs::new(context_fields).render(),
        });

        // index.ts
        files.push(PreviewFile {
            path: "src/index.ts".to_string(),
            content: IndexTs.render(),
        });

        // package.json
        files.push(PreviewFile {
            path: "package.json".to_string(),
            content: PackageJson::new(&self.schema.cli.name)
                .with_version(self.schema.cli.version.clone())
                .render(),
        });

        // tsconfig.json
        files.push(PreviewFile {
            path: "tsconfig.json".to_string(),
            content: TsConfig.render(),
        });

        // .gitignore
        files.push(PreviewFile {
            path: ".gitignore".to_string(),
            content: GitIgnore.render(),
        });

        // cli.ts
        let commands: Vec<CommandInfo> = self
            .schema
            .commands
            .iter()
            .map(|(name, cmd)| CommandInfo {
                name: name.clone(),
                description: cmd.description.clone(),
                has_subcommands: cmd.has_subcommands(),
            })
            .collect();

        files.push(PreviewFile {
            path: "src/cli.ts".to_string(),
            content: CliTs::new(
                &self.schema.cli.name,
                self.schema.cli.version.clone(),
                self.schema.cli.description.clone(),
                commands,
            )
            .render(),
        });

        // Individual command files (recursively collect all commands)
        for (name, command) in &self.schema.commands {
            self.collect_command_previews(&mut files, name, command, vec![name.clone()]);
        }

        files
    }

    /// Recursively collect command file previews.
    fn collect_command_previews(
        &self,
        files: &mut Vec<PreviewFile>,
        name: &str,
        command: &Command,
        path_segments: Vec<String>,
    ) {
        let content = self.generate_command_file(name, command, &path_segments);
        let file_path = path_segments
            .iter()
            .map(|s| to_kebab_case(s))
            .collect::<Vec<_>>()
            .join("/");

        files.push(PreviewFile {
            path: format!("src/commands/{}.ts", file_path),
            content: CommandTs::nested(path_segments.clone(), content).render(),
        });

        // Recursively collect subcommand previews
        if command.has_subcommands() {
            for (sub_name, sub_command) in &command.commands {
                let mut sub_path = path_segments.clone();
                sub_path.push(sub_name.clone());
                self.collect_command_previews(files, sub_name, sub_command, sub_path);
            }
        }
    }

    /// Generate all files into the specified output directory.
    fn generate_files(&self, output_dir: &Path) -> Result<GenerateResult> {
        let handlers_dir = output_dir.join("src").join("handlers");

        // Collect context field info
        let context_fields = self.collect_context_fields();

        // Generate context.ts
        ContextTs::new(context_fields).write(output_dir)?;

        // Generate index.ts
        IndexTs.write(output_dir)?;

        // Generate package.json
        PackageJson::new(&self.schema.cli.name)
            .with_version(self.schema.cli.version.clone())
            .write(output_dir)?;

        // Generate tsconfig.json
        TsConfig.write(output_dir)?;

        // Generate .gitignore
        GitIgnore.write(output_dir)?;

        // Generate bao.toml
        BaoToml::new(&self.schema.cli.name, Language::TypeScript)
            .with_version(self.schema.cli.version.clone())
            .write(output_dir)?;

        // Generate cli.ts with main CLI setup
        let commands: Vec<CommandInfo> = self
            .schema
            .commands
            .iter()
            .map(|(name, cmd)| CommandInfo {
                name: name.clone(),
                description: cmd.description.clone(),
                has_subcommands: cmd.has_subcommands(),
            })
            .collect();

        CliTs::new(
            &self.schema.cli.name,
            self.schema.cli.version.clone(),
            self.schema.cli.description.clone(),
            commands,
        )
        .write(output_dir)?;

        // Ensure commands directory exists
        std::fs::create_dir_all(output_dir.join("src").join("commands"))?;

        // Generate individual command files (recursively for nested commands)
        for (name, command) in &self.schema.commands {
            self.generate_command_files_recursive(output_dir, name, command, vec![name.clone()])?;
        }

        // Generate handlers
        let result = self.generate_handlers(&handlers_dir, output_dir)?;

        Ok(result)
    }

    fn collect_context_fields(&self) -> Vec<ContextFieldInfo> {
        use baobao_manifest::ContextField;

        self.schema
            .context
            .fields()
            .into_iter()
            .map(|(name, field)| {
                let env_var = field
                    .env()
                    .map(|s| s.to_string())
                    .unwrap_or_else(|| field.default_env().to_string());

                let pool = field
                    .pool_config()
                    .map(|p| PoolConfigInfo {
                        max_connections: p.max_connections,
                        min_connections: p.min_connections,
                        acquire_timeout: p.acquire_timeout,
                        idle_timeout: p.idle_timeout,
                        max_lifetime: p.max_lifetime,
                    })
                    .unwrap_or_default();

                let sqlite = field.sqlite_config().map(|s| SqliteConfigInfo {
                    path: s.path.clone(),
                    create_if_missing: s.create_if_missing,
                    read_only: s.read_only,
                    journal_mode: s.journal_mode.as_ref().map(|m| m.as_str().to_string()),
                    synchronous: s.synchronous.as_ref().map(|m| m.as_str().to_string()),
                    busy_timeout: s.busy_timeout,
                    foreign_keys: s.foreign_keys,
                });

                let field_type = match &field {
                    ContextField::Postgres(_) => ContextFieldType::Database(DatabaseType::Postgres),
                    ContextField::Mysql(_) => ContextFieldType::Database(DatabaseType::Mysql),
                    ContextField::Sqlite(_) => ContextFieldType::Database(DatabaseType::Sqlite),
                    ContextField::Http(_) => ContextFieldType::Http,
                };

                ContextFieldInfo {
                    name: name.to_string(),
                    field_type,
                    env_var,
                    is_async: field.is_async(),
                    pool,
                    sqlite,
                }
            })
            .collect()
    }

    /// Recursively generate command files for a command and all its subcommands.
    fn generate_command_files_recursive(
        &self,
        output_dir: &Path,
        name: &str,
        command: &Command,
        path_segments: Vec<String>,
    ) -> Result<()> {
        // Generate this command's file
        let content = self.generate_command_file(name, command, &path_segments);

        // Ensure parent directory exists for nested commands
        if path_segments.len() > 1 {
            let mut dir_path = output_dir.join("src").join("commands");
            for segment in &path_segments[..path_segments.len() - 1] {
                dir_path = dir_path.join(to_kebab_case(segment));
            }
            std::fs::create_dir_all(&dir_path)?;
        }

        CommandTs::nested(path_segments.clone(), content).write(output_dir)?;

        // Recursively generate subcommand files
        if command.has_subcommands() {
            for (sub_name, sub_command) in &command.commands {
                let mut sub_path = path_segments.clone();
                sub_path.push(sub_name.clone());
                self.generate_command_files_recursive(output_dir, sub_name, sub_command, sub_path)?;
            }
        }

        Ok(())
    }

    fn generate_command_file(
        &self,
        name: &str,
        command: &Command,
        path_segments: &[String],
    ) -> String {
        if command.has_subcommands() {
            self.generate_parent_command_file(name, command)
        } else {
            self.generate_leaf_command_file(name, command, path_segments)
        }
    }

    /// Generate a parent command file that only routes to subcommands.
    fn generate_parent_command_file(&self, name: &str, command: &Command) -> String {
        let camel_name = to_camel_case(name);
        let kebab_name = to_kebab_case(name);

        let mut builder = CodeBuilder::typescript();

        // Imports
        builder = Import::new("boune").named("defineCommand").render(builder);

        for subcommand_name in command.commands.keys() {
            let sub_camel = to_camel_case(subcommand_name);
            let sub_kebab = to_kebab_case(subcommand_name);
            builder = Import::new(format!("./{}/{}.ts", kebab_name, sub_kebab))
                .named(format!("{}Command", sub_camel))
                .render(builder);
        }

        // Build subcommands object
        let subcommands = command
            .commands
            .keys()
            .fold(JsObject::new(), |obj, sub_name| {
                let sub_camel = to_camel_case(sub_name);
                obj.raw(&sub_camel, format!("{}Command", sub_camel))
            });

        // Build command schema
        let schema = JsObject::new()
            .string("name", name)
            .string("description", &command.description)
            .object("subcommands", subcommands);

        builder = builder.blank().raw(&format!(
            "export const {}Command = defineCommand(",
            camel_name
        ));
        builder = schema.render(builder);
        builder = builder.raw(");");

        builder.build()
    }

    /// Generate a leaf command file that has an action handler.
    fn generate_leaf_command_file(
        &self,
        name: &str,
        command: &Command,
        path_segments: &[String],
    ) -> String {
        use baobao_core::to_pascal_case;

        let camel_name = to_camel_case(name);
        let pascal_name = to_pascal_case(name);

        // Build the handler path (kebab-case, joined by /)
        let handler_path = path_segments
            .iter()
            .map(|s| to_kebab_case(s))
            .collect::<Vec<_>>()
            .join("/");

        // Calculate relative path from command location
        let depth = path_segments.len();
        let up_path = "../".repeat(depth);

        let mut builder = CodeBuilder::typescript();

        // Imports
        let mut boune_import = Import::new("boune").named("defineCommand");
        if !command.args.is_empty() {
            boune_import = boune_import.named("argument").named_type("InferArgs");
        }
        if !command.flags.is_empty() {
            boune_import = boune_import.named("option").named_type("InferOptions");
        }
        builder = boune_import.render(builder);

        builder = Import::new(format!("{}handlers/{}.ts", up_path, handler_path))
            .named("run")
            .render(builder);

        // Extract arguments schema as const
        if !command.args.is_empty() {
            let arguments = command
                .args
                .iter()
                .fold(JsObject::new(), |obj, (arg_name, arg)| {
                    let camel = to_camel_case(arg_name);
                    let boune_type = self.map_boune_type(&arg.arg_type);
                    obj.raw(&camel, self.build_argument_chain(boune_type, arg))
                });

            builder = builder.blank();
            builder = builder.raw("const args = ");
            builder = arguments.render(builder);
            builder = builder.line(" as const;");
        }

        // Extract options schema as const
        if !command.flags.is_empty() {
            let options = command
                .flags
                .iter()
                .fold(JsObject::new(), |obj, (flag_name, flag)| {
                    let camel = to_camel_case(flag_name);
                    let boune_type = self.map_boune_type(&flag.flag_type);
                    obj.raw(&camel, self.build_option_chain(boune_type, flag))
                });

            builder = builder.blank();
            builder = builder.raw("const options = ");
            builder = options.render(builder);
            builder = builder.line(" as const;");
        }

        // Command definition
        builder = builder.blank();
        builder = self.render_command_definition(builder, &camel_name, name, command);

        // Export inferred types
        builder = builder.blank();
        if !command.args.is_empty() {
            builder = builder.line(&format!(
                "export type {}Args = InferArgs<typeof args>;",
                pascal_name
            ));
        }
        if !command.flags.is_empty() {
            builder = builder.line(&format!(
                "export type {}Options = InferOptions<typeof options>;",
                pascal_name
            ));
        }

        builder.build()
    }

    fn render_command_definition(
        &self,
        builder: CodeBuilder,
        camel_name: &str,
        name: &str,
        command: &Command,
    ) -> CodeBuilder {
        // Build action handler body
        let action = self.build_action_handler(command);

        // Build command schema - reference extracted consts
        let schema = JsObject::new()
            .string("name", name)
            .string("description", &command.description)
            .raw_if(!command.args.is_empty(), "arguments", "args")
            .raw_if(!command.flags.is_empty(), "options", "options")
            .arrow_fn("action", action);

        let builder = builder.raw(&format!(
            "export const {}Command = defineCommand(",
            camel_name
        ));
        let builder = schema.render(builder);
        builder.line(");")
    }

    fn build_argument_chain(&self, boune_type: &str, arg: &baobao_manifest::Arg) -> String {
        use crate::ast::MethodChain;

        let mut chain = MethodChain::new(format!("argument.{}", boune_type));

        if arg.required && arg.default.is_none() {
            chain = chain.call_empty("required");
        }

        if let Some(default) = &arg.default {
            chain = chain.call("default", Self::toml_to_ts_literal(default));
        }

        if let Some(desc) = &arg.description {
            chain = chain.call("describe", format!("\"{}\"", desc));
        }

        chain.build_inline()
    }

    fn build_option_chain(&self, boune_type: &str, flag: &baobao_manifest::Flag) -> String {
        use crate::ast::MethodChain;

        let mut chain = MethodChain::new(format!("option.{}", boune_type));

        if let Some(short) = flag.short_char() {
            chain = chain.call("short", format!("\"{}\"", short));
        }

        if let Some(default) = &flag.default {
            chain = chain.call("default", Self::toml_to_ts_literal(default));
        }

        if let Some(desc) = &flag.description {
            chain = chain.call("describe", format!("\"{}\"", desc));
        }

        chain.build_inline()
    }

    /// Convert a TOML value to a TypeScript literal string.
    /// Strings are quoted, numbers and booleans are raw.
    fn toml_to_ts_literal(value: &toml::Value) -> String {
        match value {
            toml::Value::String(s) => format!("\"{}\"", s),
            toml::Value::Integer(i) => i.to_string(),
            toml::Value::Float(f) => f.to_string(),
            toml::Value::Boolean(b) => b.to_string(),
            _ => String::new(),
        }
    }

    fn build_action_handler(&self, command: &Command) -> ArrowFn {
        let has_args = !command.args.is_empty();
        let has_options = !command.flags.is_empty();

        // Build destructuring pattern based on what's available
        let params = match (has_args, has_options) {
            (true, true) => "{ args, options }",
            (true, false) => "{ args }",
            (false, true) => "{ options }",
            (false, false) => "{}",
        };

        // Build run() call based on what's available
        let run_call = match (has_args, has_options) {
            (true, true) => "await run(args, options);",
            (true, false) => "await run(args);",
            (false, true) => "await run(options);",
            (false, false) => "await run();",
        };

        ArrowFn::new(params).async_().body_line(run_call)
    }

    fn map_boune_type(&self, arg_type: &baobao_manifest::ArgType) -> &'static str {
        use baobao_manifest::ArgType;
        match arg_type {
            ArgType::String => "string",
            ArgType::Int => "number",
            ArgType::Float => "number",
            ArgType::Bool => "boolean",
            ArgType::Path => "string",
        }
    }

    /// Generate handlers directory with stub files for missing handlers.
    fn generate_handlers(&self, handlers_dir: &Path, _output_dir: &Path) -> Result<GenerateResult> {
        let mut created_handlers = Vec::new();

        // Collect all expected handler paths, using kebab-case for TypeScript file names
        let expected_handlers: HashSet<String> = CommandTree::new(self.schema)
            .collect_paths()
            .into_iter()
            .map(|path| {
                path.split('/')
                    .map(to_kebab_case)
                    .collect::<Vec<_>>()
                    .join("/")
            })
            .collect();

        // Ensure handlers directory exists
        std::fs::create_dir_all(handlers_dir)?;

        // Generate stub handlers for missing commands
        for (name, command) in &self.schema.commands {
            let created =
                self.generate_handler_stubs(handlers_dir, name, command, vec![name.clone()])?;
            created_handlers.extend(created);
        }

        // Find orphan handlers using shared utility
        let handler_paths = HandlerPaths::new(handlers_dir, "ts");
        let orphan_handlers = handler_paths.find_orphans(&expected_handlers)?;

        Ok(GenerateResult {
            created_handlers,
            orphan_handlers,
        })
    }

    /// Generate stub handler files for a command (recursively for subcommands).
    fn generate_handler_stubs(
        &self,
        handlers_dir: &Path,
        name: &str,
        command: &Command,
        path_segments: Vec<String>,
    ) -> Result<Vec<String>> {
        use baobao_core::WriteResult;

        let mut created = Vec::new();

        let kebab_name = to_kebab_case(name);
        let display_path = path_segments
            .iter()
            .map(|s| to_kebab_case(s))
            .collect::<Vec<_>>()
            .join("/");

        if command.has_subcommands() {
            // Create directory for subcommands
            let subdir = handlers_dir.join(&kebab_name);
            std::fs::create_dir_all(&subdir)?;

            // Recursively generate stubs for subcommands
            for (sub_name, sub_command) in &command.commands {
                let mut sub_path = path_segments.clone();
                sub_path.push(sub_name.clone());
                let sub_created =
                    self.generate_handler_stubs(&subdir, sub_name, sub_command, sub_path)?;
                created.extend(sub_created);
            }
        } else {
            // Leaf command - generate stub if file doesn't exist
            let has_args = !command.args.is_empty();
            let has_options = !command.flags.is_empty();
            let stub = HandlerTs::nested(name, path_segments, has_args, has_options);
            let result = stub.write(handlers_dir)?;

            if matches!(result, WriteResult::Written) {
                created.push(format!("{}.ts", display_path));
            }
        }

        Ok(created)
    }
}