Added CLI install command

cli/Cargo.toml

@@ -19,6 +19,7 @@ chrono = "0.4.39"
 dotenv_codegen = "0.15.0"
 inquire = "0.7.5"
 clearscreen = "4.0.1"
+dirs = "5.0"
 telchar-codegen = { version = "0.1.1", path = "../codegen" }
 
 [build-dependencies]

cli/src/command/codegen.rs

@@ -1,16 +1,19 @@
-use crate::run_codegen_query;
+use std::str::FromStr;
+use dirs::home_dir;
+
+use telchar_codegen::Codegen;
+use telchar_codegen::template::Template;
 
 pub async fn run(sub_matches: &clap::ArgMatches) {
-    let graphql_url = dotenv!("GRAPHQL_URL");
+    let codegen = Codegen::new();
 
     let blueprint_reference = sub_matches.get_one::<String>("blueprint").expect("required");
     let template_reference = sub_matches.get_one::<String>("template").expect("required");
     if let Some((scope, name)) = blueprint_reference.split_once('/') {
-        let codegen = run_codegen_query(graphql_url.to_string(), scope.to_string(), name.to_string(), template_reference.to_string()).await;
-        match codegen {
-            Some(codegen) => println!("{}", codegen),
-            None => println!("Blueprint not found")
-        }
+        let blueprint_path = home_dir().unwrap().join(".telchar").join("protocol").join(format!("{}_{}.json", scope, name));
+        let blueprint = codegen.get_blueprint_from_path(blueprint_path.to_str().unwrap().to_string());
+        let template = Template::from_str(&template_reference).unwrap();
+        println!("{}", codegen.get_template_from_blueprint(blueprint, template));
     } else {
         println!("Invalid blueprint reference provided");
     }

cli/src/command/install.rs

@@ -0,0 +1,32 @@
+use std::fs;
+use dirs::home_dir;
+use crate::run_blueprint_query;
+
+pub async fn run(sub_matches: &clap::ArgMatches) {
+    let graphql_url = dotenv!("GRAPHQL_URL");
+
+    let blueprint_reference = sub_matches.get_one::<String>("blueprint").expect("required");
+    if let Some((scope, name)) = blueprint_reference.split_once('/') {
+        let blueprint_url = run_blueprint_query(graphql_url.to_string(), scope.to_string(), name.to_string()).await;
+        if let Some(blueprint_url) = blueprint_url {
+            let telchar_path = home_dir().unwrap().join(".telchar").join("protocol");
+            fs::create_dir_all(&telchar_path).unwrap();
+
+            let blueprint_path = telchar_path.join(format!("{}_{}.json", scope, name));
+
+            let mut url = blueprint_url;
+            if url.contains("github.com") {
+                url = url.replace("github.com", "raw.githubusercontent.com").replace("/blob", "");
+            }
+            let response = surf::get(url).await.unwrap().body_string().await.unwrap();
+
+            fs::write(blueprint_path, response).unwrap();
+
+            println!("Blueprint installed");
+        } else {
+            println!("Blueprint not found");
+        }
+    } else {
+        println!("Invalid blueprint reference provided");
+    }
+}

cli/src/command/mod.rs

@@ -1,15 +1,15 @@
+mod install;
 mod codegen;
-mod codegen_local;
 mod publish;
 
 pub async fn execute(matches: clap::ArgMatches) {
     match matches.subcommand() {
+        Some(("install", sub_matches)) => {
+            install::run(sub_matches).await;
+        }
         Some(("codegen", sub_matches)) => {
             codegen::run(sub_matches).await;
         }
-        Some(("codegen-local", sub_matches)) => {
-            codegen_local::run(sub_matches).await;
-        }
         Some(("publish", _)) => {
             publish::run().await;
         }

cli/src/main.rs

@@ -15,7 +15,6 @@ mod schema {}
 pub struct CodegenQueryVariables {
     pub name: String,
     pub scope: String,
-    pub template: String,
 }
 
 #[derive(cynic::QueryFragment, Debug)]
@@ -28,21 +27,14 @@ pub struct CodegenQuery {
 #[derive(cynic::QueryFragment, Debug)]
 #[cynic(variables = "CodegenQueryVariables")]
 pub struct Dapp {
-    pub blueprint: DappBlueprint,
+    pub blueprint_url: String,
 }
 
-#[derive(cynic::QueryFragment, Debug)]
-#[cynic(variables = "CodegenQueryVariables")]
-pub struct DappBlueprint {
-    #[arguments(template: $template)]
-    pub codegen: String,
-}
-
-async fn run_codegen_query(graphql_url: String, scope: String, name: String, template: String) -> Option<String> {
-    let query = CodegenQuery::build(CodegenQueryVariables { name, scope, template });
+async fn run_blueprint_query(graphql_url: String, scope: String, name: String) -> Option<String> {
+    let query = CodegenQuery::build(CodegenQueryVariables { name, scope });
     let response = surf::post(graphql_url).run_graphql(query).await.unwrap().data;
     match response {
-        Some(CodegenQuery { dapp: Some(dapp) }) => Some(dapp.blueprint.codegen),
+        Some(CodegenQuery { dapp: Some(dapp) }) => Some(dapp.blueprint_url),
         _ => None
     }
 }
@@ -53,18 +45,17 @@ async fn main() {
         .about("Telchar CLI")
         .subcommand_required(true)
         .arg_required_else_help(true)
+        .subcommand(
+            Command::new("install")
+                .about("Installs a blueprint from the registry")
+                .arg(arg!(<blueprint> "The blueprint reference for installation"))
+                .arg_required_else_help(true))
         .subcommand(
             Command::new("codegen")
                 .about("Generates the boilerplate code for the selected blueprint")
                 .arg(arg!(<blueprint> "The blueprint reference for the code generation"))
                 .arg(arg!(<template> "The template reference for the code generation"))
                 .arg_required_else_help(true))
-        .subcommand(
-            Command::new("codegen-local")
-                .about("Generates the boilerplate code for the selected local blueprint file")
-                .arg(arg!(<blueprint_path> "The blueprint file path reference for the code generation"))
-                .arg(arg!(<template> "The template reference for the code generation"))
-                .arg_required_else_help(true))
         .subcommand(
             Command::new("publish")
                 .about("Publish a blueprint to the registry"));