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

#![deny(rust_2018_idioms, unsafe_code)]

mod commands;
mod json_rpc_stdio;
mod logger;

use schema_connector::{BoxFuture, ConnectorHost, ConnectorResult};
use schema_core::rpc_api;
use std::sync::Arc;
use structopt::StructOpt;

/// When no subcommand is specified, the schema engine will default to starting as a JSON-RPC
/// server over stdio.
#[derive(Debug, StructOpt)]
#[structopt(version = env!("GIT_HASH"))]
struct SchemaEngineCli {
    /// Path to the datamodel
    #[structopt(short = "d", long, name = "FILE")]
    datamodel: Option<String>,
    #[structopt(subcommand)]
    cli_subcommand: Option<SubCommand>,
}

#[derive(Debug, StructOpt)]
enum SubCommand {
    /// Doesn't start a server, but allows running specific commands against Prisma.
    #[structopt(name = "cli")]
    Cli(commands::Cli),
}

#[tokio::main]
async fn main() {
    set_panic_hook();
    logger::init_logger();

    let input = SchemaEngineCli::from_args();

    match input.cli_subcommand {
        None => start_engine(input.datamodel.as_deref()).await,
        Some(SubCommand::Cli(cli_command)) => {
            tracing::info!(git_hash = env!("GIT_HASH"), "Starting schema engine CLI");
            cli_command.run().await;
        }
    }
}

fn set_panic_hook() {
    std::panic::set_hook(Box::new(move |panic_info| {
        let message = panic_info
            .payload()
            .downcast_ref::<&str>()
            .copied()
            .or_else(|| panic_info.payload().downcast_ref::<String>().map(|s| s.as_str()))
            .unwrap_or("<unknown panic>");

        let location = panic_info
            .location()
            .map(|loc| loc.to_string())
            .unwrap_or_else(|| "<unknown location>".to_owned());

        tracing::error!(
            is_panic = true,
            backtrace = ?backtrace::Backtrace::new(),
            location = %location,
            "[{}] {}",
            location,
            message
        );
        std::process::exit(101);
    }));
}

struct JsonRpcHost {
    client: json_rpc_stdio::Client,
}

impl ConnectorHost for JsonRpcHost {
    fn print<'a>(&'a self, text: &'a str) -> BoxFuture<'a, ConnectorResult<()>> {
        Box::pin(async move {
            // Adapter to be removed when https://github.com/prisma/prisma/issues/11761 is closed.
            assert!(!text.is_empty());
            assert!(text.ends_with('\n'));
            let text = &text[..text.len() - 1];

            let notification = serde_json::json!({ "content": text });

            let _: std::collections::HashMap<(), ()> =
                self.client.call("print".to_owned(), notification).await.unwrap();
            Ok(())
        })
    }
}

async fn start_engine(datamodel_location: Option<&str>) {
    use std::io::Read as _;

    tracing::info!(git_hash = env!("GIT_HASH"), "Starting schema engine RPC server",);

    let datamodel = datamodel_location.map(|location| {
        let mut file = match std::fs::File::open(location) {
            Ok(file) => file,
            Err(e) => panic!("Error opening datamodel file in `{location}`: {e}"),
        };

        let mut datamodel = String::new();

        if let Err(e) = file.read_to_string(&mut datamodel) {
            panic!("Error reading datamodel file `{location}`: {e}");
        };

        datamodel
    });

    let (client, adapter) = json_rpc_stdio::new_client();
    let host = JsonRpcHost { client };

    let api = rpc_api(datamodel, Arc::new(host));
    // Block the thread and handle IO in async until EOF.
    json_rpc_stdio::run_with_client(&api, adapter).await.unwrap();
}