Method run

crates/devsql/src/tools/impact.rs:42–143

(&self, ctx: CommandContext)

#[async_trait::async_trait]
impl CommandHandler for ImpactHandler {
    async fn run(&self, ctx: CommandContext) -> CommandResult {
        let file = match ctx.args.get("file").and_then(|v| v.as_str()) {
            Some(f) => f.to_string(),
            None => {
                return CommandResult::Error {
                    code: "MISSING_ARG".into(),
                    message: "Missing required argument: file".into(),
                    retryable: false,
                    exit_code: Some(1),
                    cta: None,
                };
            }
        };

        let (mut engine, _repo_path) = match engine_from_options(&ctx.options) {
            Ok(v) => v,
            Err(e) => return e,
        };

        // Load symbols and imports tables
        if let Err(e) = engine.load_code_tables(&["symbols", "imports"]) {
            return CommandResult::Error {
                code: "LOAD_ERROR".into(),
                message: format!("Failed to load code tables: {e}"),
                retryable: false,
                exit_code: Some(1),
                cta: None,
            };
        }

        // Find exported symbols from the target file
        let exports_sql = format!(
            "SELECT name, kind, line_start, signature, visibility \
             FROM symbols \
             WHERE file_path LIKE '%{file}%' \
               AND (visibility = 'pub' OR visibility = 'public' OR visibility IS NULL) \
             ORDER BY line_start"
        );

        let exported_symbols = match engine.query(&exports_sql) {
            Ok(rows) => rows,
            Err(e) => {
                return CommandResult::Error {
                    code: "QUERY_ERROR".into(),
                    message: format!("Exports query failed: {e}"),
                    retryable: false,
                    exit_code: Some(1),
                    cta: None,
                };
            }
        };

        // Collect exported symbol names for dependency search
        let symbol_names: Vec<String> = exported_symbols
            .iter()
            .filter_map(|s| s.get("name").and_then(|v| v.as_str()).map(String::from))
            .collect();