fallow_cli/report/
json.rs

1use std::path::Path;
2use std::process::ExitCode;
3use std::time::Duration;
4
5use fallow_core::duplicates::DuplicationReport;
6use fallow_core::results::AnalysisResults;
7
8pub(super) fn print_json(results: &AnalysisResults, root: &Path, elapsed: Duration) -> ExitCode {
9    match build_json(results, root, elapsed) {
10        Ok(output) => match serde_json::to_string_pretty(&output) {
11            Ok(json) => {
12                println!("{json}");
13                ExitCode::SUCCESS
14            }
15            Err(e) => {
16                eprintln!("Error: failed to serialize JSON output: {e}");
17                ExitCode::from(2)
18            }
19        },
20        Err(e) => {
21            eprintln!("Error: failed to serialize results: {e}");
22            ExitCode::from(2)
23        }
24    }
25}
26
27/// JSON output schema version as an integer (independent of tool version).
28///
29/// Bump this when the structure of the JSON output changes in a
30/// backwards-incompatible way (removing/renaming fields, changing types).
31/// Adding new fields is always backwards-compatible and does not require a bump.
32const SCHEMA_VERSION: u32 = 2;
33
34/// Build the JSON output value for analysis results.
35///
36/// Metadata fields (`schema_version`, `version`, `elapsed_ms`, `total_issues`)
37/// appear first in the output for readability. Paths are made relative to `root`.
38pub fn build_json(
39    results: &AnalysisResults,
40    root: &Path,
41    elapsed: Duration,
42) -> Result<serde_json::Value, serde_json::Error> {
43    let results_value = serde_json::to_value(results)?;
44
45    let mut map = serde_json::Map::new();
46    map.insert(
47        "schema_version".to_string(),
48        serde_json::json!(SCHEMA_VERSION),
49    );
50    map.insert(
51        "version".to_string(),
52        serde_json::json!(env!("CARGO_PKG_VERSION")),
53    );
54    map.insert(
55        "elapsed_ms".to_string(),
56        serde_json::json!(elapsed.as_millis()),
57    );
58    map.insert(
59        "total_issues".to_string(),
60        serde_json::json!(results.total_issues()),
61    );
62
63    if let serde_json::Value::Object(results_map) = results_value {
64        for (key, value) in results_map {
65            map.insert(key, value);
66        }
67    }
68
69    let mut output = serde_json::Value::Object(map);
70    let root_prefix = format!("{}/", root.display());
71    strip_root_prefix(&mut output, &root_prefix);
72    Ok(output)
73}
74
75/// Recursively strip the root prefix from all string values in the JSON tree.
76///
77/// This converts absolute paths (e.g., `/home/runner/work/repo/repo/src/utils.ts`)
78/// to relative paths (`src/utils.ts`) for all output fields.
79fn strip_root_prefix(value: &mut serde_json::Value, prefix: &str) {
80    match value {
81        serde_json::Value::String(s) => {
82            if let Some(rest) = s.strip_prefix(prefix) {
83                *s = rest.to_string();
84            }
85        }
86        serde_json::Value::Array(arr) => {
87            for item in arr {
88                strip_root_prefix(item, prefix);
89            }
90        }
91        serde_json::Value::Object(map) => {
92            for (_, v) in map.iter_mut() {
93                strip_root_prefix(v, prefix);
94            }
95        }
96        _ => {}
97    }
98}
99
100pub(super) fn print_health_json(
101    report: &crate::health_types::HealthReport,
102    root: &Path,
103    elapsed: Duration,
104) -> ExitCode {
105    let report_value = match serde_json::to_value(report) {
106        Ok(v) => v,
107        Err(e) => {
108            eprintln!("Error: failed to serialize health report: {e}");
109            return ExitCode::from(2);
110        }
111    };
112
113    let mut map = serde_json::Map::new();
114    map.insert(
115        "schema_version".to_string(),
116        serde_json::json!(SCHEMA_VERSION),
117    );
118    map.insert(
119        "version".to_string(),
120        serde_json::json!(env!("CARGO_PKG_VERSION")),
121    );
122    map.insert(
123        "elapsed_ms".to_string(),
124        serde_json::json!(elapsed.as_millis()),
125    );
126    if let serde_json::Value::Object(report_map) = report_value {
127        for (key, value) in report_map {
128            map.insert(key, value);
129        }
130    }
131    let mut output = serde_json::Value::Object(map);
132    let root_prefix = format!("{}/", root.display());
133    strip_root_prefix(&mut output, &root_prefix);
134
135    match serde_json::to_string_pretty(&output) {
136        Ok(json) => {
137            println!("{json}");
138            ExitCode::SUCCESS
139        }
140        Err(e) => {
141            eprintln!("Error: failed to serialize JSON output: {e}");
142            ExitCode::from(2)
143        }
144    }
145}
146
147pub(super) fn print_duplication_json(report: &DuplicationReport, elapsed: Duration) -> ExitCode {
148    let report_value = match serde_json::to_value(report) {
149        Ok(v) => v,
150        Err(e) => {
151            eprintln!("Error: failed to serialize duplication report: {e}");
152            return ExitCode::from(2);
153        }
154    };
155
156    // Metadata fields first, then report data
157    let mut map = serde_json::Map::new();
158    map.insert(
159        "schema_version".to_string(),
160        serde_json::json!(SCHEMA_VERSION),
161    );
162    map.insert(
163        "version".to_string(),
164        serde_json::json!(env!("CARGO_PKG_VERSION")),
165    );
166    map.insert(
167        "elapsed_ms".to_string(),
168        serde_json::json!(elapsed.as_millis()),
169    );
170    if let serde_json::Value::Object(report_map) = report_value {
171        for (key, value) in report_map {
172            map.insert(key, value);
173        }
174    }
175    let output = serde_json::Value::Object(map);
176
177    match serde_json::to_string_pretty(&output) {
178        Ok(json) => {
179            println!("{json}");
180            ExitCode::SUCCESS
181        }
182        Err(e) => {
183            eprintln!("Error: failed to serialize JSON output: {e}");
184            ExitCode::from(2)
185        }
186    }
187}
188
189pub(super) fn print_trace_json<T: serde::Serialize>(value: &T) {
190    match serde_json::to_string_pretty(value) {
191        Ok(json) => println!("{json}"),
192        Err(e) => {
193            eprintln!("Error: failed to serialize trace output: {e}");
194            #[expect(clippy::exit)]
195            std::process::exit(2);
196        }
197    }
198}
199
200#[cfg(test)]
201mod tests {
202    use super::*;
203    use fallow_core::extract::MemberKind;
204    use fallow_core::results::*;
205    use std::path::{Path, PathBuf};
206    use std::time::Duration;
207
208    /// Helper: build an `AnalysisResults` populated with one issue of every type.
209    fn sample_results(root: &Path) -> AnalysisResults {
210        let mut r = AnalysisResults::default();
211
212        r.unused_files.push(UnusedFile {
213            path: root.join("src/dead.ts"),
214        });
215        r.unused_exports.push(UnusedExport {
216            path: root.join("src/utils.ts"),
217            export_name: "helperFn".to_string(),
218            is_type_only: false,
219            line: 10,
220            col: 4,
221            span_start: 120,
222            is_re_export: false,
223        });
224        r.unused_types.push(UnusedExport {
225            path: root.join("src/types.ts"),
226            export_name: "OldType".to_string(),
227            is_type_only: true,
228            line: 5,
229            col: 0,
230            span_start: 60,
231            is_re_export: false,
232        });
233        r.unused_dependencies.push(UnusedDependency {
234            package_name: "lodash".to_string(),
235            location: DependencyLocation::Dependencies,
236            path: root.join("package.json"),
237        });
238        r.unused_dev_dependencies.push(UnusedDependency {
239            package_name: "jest".to_string(),
240            location: DependencyLocation::DevDependencies,
241            path: root.join("package.json"),
242        });
243        r.unused_enum_members.push(UnusedMember {
244            path: root.join("src/enums.ts"),
245            parent_name: "Status".to_string(),
246            member_name: "Deprecated".to_string(),
247            kind: MemberKind::EnumMember,
248            line: 8,
249            col: 2,
250        });
251        r.unused_class_members.push(UnusedMember {
252            path: root.join("src/service.ts"),
253            parent_name: "UserService".to_string(),
254            member_name: "legacyMethod".to_string(),
255            kind: MemberKind::ClassMethod,
256            line: 42,
257            col: 4,
258        });
259        r.unresolved_imports.push(UnresolvedImport {
260            path: root.join("src/app.ts"),
261            specifier: "./missing-module".to_string(),
262            line: 3,
263            col: 0,
264        });
265        r.unlisted_dependencies.push(UnlistedDependency {
266            package_name: "chalk".to_string(),
267            imported_from: vec![root.join("src/cli.ts")],
268        });
269        r.duplicate_exports.push(DuplicateExport {
270            export_name: "Config".to_string(),
271            locations: vec![
272                DuplicateLocation {
273                    path: root.join("src/config.ts"),
274                    line: 15,
275                    col: 0,
276                },
277                DuplicateLocation {
278                    path: root.join("src/types.ts"),
279                    line: 30,
280                    col: 0,
281                },
282            ],
283        });
284        r.circular_dependencies.push(CircularDependency {
285            files: vec![root.join("src/a.ts"), root.join("src/b.ts")],
286            length: 2,
287        });
288
289        r
290    }
291
292    #[test]
293    fn json_output_has_metadata_fields() {
294        let root = PathBuf::from("/project");
295        let results = AnalysisResults::default();
296        let elapsed = Duration::from_millis(123);
297        let output = build_json(&results, &root, elapsed).expect("should serialize");
298
299        assert_eq!(output["schema_version"], 2);
300        assert!(output["version"].is_string());
301        assert_eq!(output["elapsed_ms"], 123);
302        assert_eq!(output["total_issues"], 0);
303    }
304
305    #[test]
306    fn json_output_includes_issue_arrays() {
307        let root = PathBuf::from("/project");
308        let results = sample_results(&root);
309        let elapsed = Duration::from_millis(50);
310        let output = build_json(&results, &root, elapsed).expect("should serialize");
311
312        assert!(output["unused_files"].is_array());
313        assert!(output["unused_exports"].is_array());
314        assert!(output["unused_types"].is_array());
315        assert!(output["unused_dependencies"].is_array());
316        assert!(output["unused_dev_dependencies"].is_array());
317        assert!(output["unused_enum_members"].is_array());
318        assert!(output["unused_class_members"].is_array());
319        assert!(output["unresolved_imports"].is_array());
320        assert!(output["unlisted_dependencies"].is_array());
321        assert!(output["duplicate_exports"].is_array());
322        assert!(output["type_only_dependencies"].is_array());
323    }
324
325    #[test]
326    fn json_metadata_fields_appear_first() {
327        let root = PathBuf::from("/project");
328        let results = AnalysisResults::default();
329        let elapsed = Duration::from_millis(0);
330        let output = build_json(&results, &root, elapsed).expect("should serialize");
331        let keys: Vec<&String> = output.as_object().unwrap().keys().collect();
332        assert_eq!(keys[0], "schema_version");
333        assert_eq!(keys[1], "version");
334        assert_eq!(keys[2], "elapsed_ms");
335        assert_eq!(keys[3], "total_issues");
336    }
337
338    #[test]
339    fn json_total_issues_matches_results() {
340        let root = PathBuf::from("/project");
341        let results = sample_results(&root);
342        let total = results.total_issues();
343        let elapsed = Duration::from_millis(0);
344        let output = build_json(&results, &root, elapsed).expect("should serialize");
345
346        assert_eq!(output["total_issues"], total);
347    }
348
349    #[test]
350    fn json_unused_export_contains_expected_fields() {
351        let root = PathBuf::from("/project");
352        let mut results = AnalysisResults::default();
353        results.unused_exports.push(UnusedExport {
354            path: root.join("src/utils.ts"),
355            export_name: "helperFn".to_string(),
356            is_type_only: false,
357            line: 10,
358            col: 4,
359            span_start: 120,
360            is_re_export: false,
361        });
362        let elapsed = Duration::from_millis(0);
363        let output = build_json(&results, &root, elapsed).expect("should serialize");
364
365        let export = &output["unused_exports"][0];
366        assert_eq!(export["export_name"], "helperFn");
367        assert_eq!(export["line"], 10);
368        assert_eq!(export["col"], 4);
369        assert_eq!(export["is_type_only"], false);
370        assert_eq!(export["span_start"], 120);
371        assert_eq!(export["is_re_export"], false);
372    }
373
374    #[test]
375    fn json_serializes_to_valid_json() {
376        let root = PathBuf::from("/project");
377        let results = sample_results(&root);
378        let elapsed = Duration::from_millis(42);
379        let output = build_json(&results, &root, elapsed).expect("should serialize");
380
381        let json_str = serde_json::to_string_pretty(&output).expect("should stringify");
382        let reparsed: serde_json::Value =
383            serde_json::from_str(&json_str).expect("JSON output should be valid JSON");
384        assert_eq!(reparsed, output);
385    }
386}
fallow_cli/report/json.rs

fallow_cli/report/
json.rs
