source-map-tauri 0.2.0

Static Tauri app scanner that emits Meilisearch-ready NDJSON
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135

pub mod cli;
pub mod config;
pub mod discovery;
pub mod frontend;
pub mod ids;
pub mod linker;
pub mod lsp;
pub mod meili;
pub mod model;
pub mod output;
pub mod projects;
pub mod r#rust;
pub mod scan;
pub mod security;
pub mod sourcemaps;
pub mod tauri_config;
pub mod validate;

use anyhow::Result;
use clap::Parser;

use crate::cli::{Cli, Command};

pub fn run() -> Result<()> {
    let cli = Cli::parse();
    let config = config::ResolvedConfig::from_cli(&cli)?;

    match &cli.command {
        Command::Init => config::init_project(&config),
        Command::Doctor => {
            let report = discovery::doctor(&config)?;
            let mut value = serde_json::to_value(report)?;
            if let Some(health) = meili::doctor_health(&config) {
                value["meilisearch_health"] = health;
            }
            println!("{}", serde_json::to_string_pretty(&value)?);
            Ok(())
        }
        Command::Scan { out } => {
            let runtime = config.with_output_override(out.clone());
            let bundle = scan::scan_project(&runtime)?;
            output::write_scan_bundle(&runtime.output_dir, &bundle)?;
            println!("{}", serde_json::to_string_pretty(&bundle.summary)?);
            Ok(())
        }
        Command::Upload {
            meili_url,
            meili_key,
            index,
            input,
            edges,
            warnings,
            wait,
            batch_size,
        } => meili::upload(
            &config,
            meili::UploadRequest {
                meili_url: meili_url.as_deref(),
                meili_key: meili_key.as_deref(),
                index: index.as_deref(),
                input,
                edges: edges.as_ref().map(|path| path.as_path()),
                warnings: warnings.as_ref().map(|path| path.as_path()),
                wait: *wait,
                _batch_size: *batch_size,
            },
        ),
        Command::Reindex {
            meili_url,
            meili_key,
            index,
            out,
            wait,
            batch_size,
        } => {
            let runtime = config.with_output_override(out.clone());
            let mut bundle = scan::scan_project(&runtime)?;
            if let Some(index_name) = index.as_ref() {
                bundle.project_info.index_uid = index_name.clone();
            }
            output::write_scan_bundle(&runtime.output_dir, &bundle)?;
            meili::upload(
                &runtime,
                meili::UploadRequest {
                    meili_url: meili_url.as_deref(),
                    meili_key: meili_key.as_deref(),
                    index: index.as_deref(),
                    input: &runtime.output_dir.join("artifacts.ndjson"),
                    edges: Some(&runtime.output_dir.join("edges.ndjson")),
                    warnings: Some(&runtime.output_dir.join("warnings.ndjson")),
                    wait: *wait,
                    _batch_size: *batch_size,
                },
            )
        }
        Command::Search {
            meili_url,
            meili_key,
            index,
            query,
            filter,
            limit,
        } => meili::search(
            &config,
            meili_url.as_deref(),
            meili_key.as_deref(),
            index.as_deref(),
            query,
            filter.as_deref(),
            *limit,
        ),
        Command::Trace {
            bundle,
            line,
            column,
        } => {
            let result =
                sourcemaps::trace::trace_bundle_frame(&config.root, bundle, *line, *column)?;
            println!("{}", serde_json::to_string_pretty(&result)?);
            Ok(())
        }
        Command::Validate { input } => {
            validate::validate_output_dir(input)?;
            println!("validation ok");
            Ok(())
        }
        Command::PrintSchema { kind } => {
            println!(
                "{}",
                serde_json::to_string_pretty(&model::schema_for_kind(kind)?)?
            );
            Ok(())
        }
    }
}