feat(cli): database reset interactive (wip)

michael-0acf4 · michael-0acf4 · commit d6222baad51d · 2024-03-07T19:15:14.000+03:00
diff --git a/examples/deploy/deploy.mjs b/examples/deploy/deploy.mjs
@@ -20,7 +20,6 @@ import * as path from "path";
 
 const tg = await typegraph({
   name: "deploy-example-node",
-  disableAutoSerialization: true // disable print
 }, (g) => {
     const deno = new DenoRuntime();
     const python = new PythonRuntime();
diff --git a/examples/deploy/deploy.py b/examples/deploy/deploy.py
@@ -15,7 +15,7 @@
 from os import path
 
 
-@typegraph(disable_auto_serialization=True)  # disable print
+@typegraph()
 def deploy_example_python(g: Graph):
     deno = DenoRuntime()
     python = PythonRuntime()
diff --git a/meta-cli/src/cli/deploy.rs b/meta-cli/src/cli/deploy.rs
@@ -116,7 +116,7 @@ impl Deploy {
             .with_context(|| format!("building node from config: {node_config:#?}"))?;
 
         ServerStore::with(Some(Command::Deploy), Some(config.as_ref().to_owned()));
-        ServerStore::set_migration_action(MigrationAction {
+        ServerStore::set_migration_action_glob(MigrationAction {
             create: deploy.options.create_migration,
             reset: deploy.options.allow_destructive, // reset on drift
         });
@@ -262,9 +262,13 @@ mod default_mode {
                     match event {
                         LoaderEvent::Typegraph(tg) => match tg.get_response_or_fail() {
                             Ok(res) => {
-                                match PushResult::new(self.console.clone(), res.as_ref().clone()) {
+                                match PushResult::new(
+                                    self.console.clone(),
+                                    self.loader.clone(),
+                                    res.as_ref().clone(),
+                                ) {
                                     Ok(push) => {
-                                        if let Err(e) = push.finalize() {
+                                        if let Err(e) = push.finalize().await {
                                             panic!("{}", e.to_string());
                                         }
                                     }
@@ -399,9 +403,9 @@ mod watch_mode {
                                 .unwrap()
                                 .as_ref()
                                 .to_owned();
-                            match PushResult::new(console.clone(), response) {
+                            match PushResult::new(console.clone(), loader.clone(), response) {
                                 Ok(push) => {
-                                    if let Err(e) = push.finalize() {
+                                    if let Err(e) = push.finalize().await {
                                         panic!("{}", e.to_string());
                                     }
                                     RetryManager::clear_counter(&tg.path);
diff --git a/meta-cli/src/com/server.rs b/meta-cli/src/com/server.rs
@@ -50,14 +50,15 @@ struct QueryConfigParams {
 
 #[get("/config")]
 async fn config(req: HttpRequest) -> impl Responder {
-    let mut parsed = Query::<QueryConfigParams>::from_query(req.query_string()).unwrap();
+    let parsed = Query::<QueryConfigParams>::from_query(req.query_string()).unwrap();
 
-    parsed.typegraph_path.pop(); // pop file.ext
-    let artefact_base_dir = parsed.typegraph_path.clone();
+    let mut artefact_base_dir = parsed.typegraph_path.clone();
+    artefact_base_dir.pop(); // pop file.ext
 
     let endpoint = ServerStore::get_endpoint();
     let secrets = ServerStore::get_secrets();
-    let migration_action = ServerStore::get_migration_action();
+    let migration_action = ServerStore::get_migration_action(&parsed.typegraph_path);
+
     let prefix = ServerStore::get_prefix();
     match ServerStore::get_config() {
         Some(config) => {
diff --git a/meta-cli/src/com/store.rs b/meta-cli/src/com/store.rs
@@ -55,7 +55,8 @@ pub struct MigrationAction {
 pub struct ServerStore {
     config: Option<Config>,
     command: Option<Command>,
-    migration_action: MigrationAction,
+    migration_action_glob: MigrationAction,
+    migration_action: HashMap<PathBuf, Arc<MigrationAction>>,
     secrets: HashMap<String, String>,
     endpoint: Endpoint,
     prefix: Option<String>,
@@ -101,7 +102,7 @@ impl ServerStore {
 
     pub fn add_response(tg_name: PathBuf, response: SDKResponse) {
         with_store_mut(|s| {
-            s.sdk_responses.insert(tg_name, Arc::new(response));
+            s.sdk_responses.insert(tg_name, response.into());
         })
     }
 
@@ -120,12 +121,31 @@ impl ServerStore {
         with_store(|s| s.sdk_responses.clone())
     }
 
-    pub fn set_migration_action(option: MigrationAction) {
-        with_store_mut(|s| s.migration_action = option)
+    pub fn set_migration_action_glob(option: MigrationAction) {
+        with_store_mut(|s| s.migration_action_glob = option)
     }
 
-    pub fn get_migration_action() -> MigrationAction {
-        with_store(|s| s.migration_action.to_owned())
+    pub fn get_migration_action_glob() -> MigrationAction {
+        with_store(|s| s.migration_action_glob.to_owned())
+    }
+
+    pub fn set_migration_action(tg_path: PathBuf, option: MigrationAction) {
+        with_store_mut(|s| {
+            s.migration_action.insert(tg_path, option.into());
+        })
+    }
+
+    pub fn get_migration_action(tg_path: &PathBuf) -> MigrationAction {
+        with_store(|s| {
+            if let Some(mig_action) = s.migration_action.get(tg_path) {
+                println!(
+                    "Specific migration action was defined for {}",
+                    tg_path.display()
+                );
+                return mig_action.as_ref().to_owned();
+            }
+            s.migration_action_glob.to_owned()
+        })
     }
 
     pub fn set_prefix(prefix: Option<String>) {
diff --git a/meta-cli/src/deploy/push/pusher.rs b/meta-cli/src/deploy/push/pusher.rs
@@ -13,7 +13,9 @@ use anyhow::Result;
 use serde::Deserialize;
 
 use crate::com::{responses::SDKResponse, store::ServerStore};
+use crate::deploy::actors::console::input::{Confirm, ConfirmHandler};
 use crate::deploy::actors::console::{Console, ConsoleActor};
+use crate::deploy::actors::loader::{LoadModule, LoaderActor};
 
 use lazy_static::lazy_static;
 
@@ -96,11 +98,16 @@ pub struct PushResult {
     failure: Option<PushFailure>,
     original_name: String,
     console: Addr<ConsoleActor>,
+    loader: Addr<LoaderActor>,
     sdk_response: SDKResponse,
 }
 
 impl PushResult {
-    pub fn new(console: Addr<ConsoleActor>, sdk_response: SDKResponse) -> Result<Self> {
+    pub fn new(
+        console: Addr<ConsoleActor>,
+        loader: Addr<LoaderActor>,
+        sdk_response: SDKResponse,
+    ) -> Result<Self> {
         let raw = sdk_response.as_push_result()?;
 
         let failure = match raw.failure {
@@ -115,11 +122,12 @@ impl PushResult {
             failure,
             original_name: sdk_response.typegraph_name.clone(),
             console,
+            loader,
             sdk_response,
         })
     }
 
-    pub fn finalize(&self) -> Result<()> {
+    pub async fn finalize(&self) -> Result<()> {
         let name = self.name.clone();
         self.console.info(format!(
             "{} Successfully pushed typegraph {name}.",
@@ -131,9 +139,9 @@ impl PushResult {
             .unwrap()
             .prisma_migrations_dir_rel(&self.original_name);
 
+        // TODO: use unpack from sdk? This requires another load event though.
         for migrations in self.migrations.iter() {
             let dest = migdir.join(&migrations.runtime);
-            // TODO async??
             if let Err(e) = common::archive::unpack(&dest, Some(migrations.migrations.clone())) {
                 self.console.error(format!(
                     "Error while unpacking migrations into {:?}",
@@ -142,7 +150,7 @@ impl PushResult {
                 self.console.error(format!("{e:?}"));
             } else {
                 self.console.info(format!(
-                    "Successfully unpacked migrations for {name}/{} at {:?}!",
+                    "Successfully unpacked migrations for {name}/{} at {:?}",
                     migrations.runtime, dest
                 ));
             }
@@ -158,17 +166,142 @@ impl PushResult {
                     self.console.error(f.message);
                 }
                 PushFailure::DatabaseResetRequired(failure) => {
-                    todo!("database reset required {:?}", failure);
-                }
-                PushFailure::NullConstraintViolation(failure) => {
-                    todo!("null constraint violation {:?}", failure);
+                    handle_database_reset(
+                        self.console.clone(),
+                        self.loader.clone(),
+                        failure,
+                        self.sdk_response.clone(),
+                    )
+                    .await?
                 }
+                PushFailure::NullConstraintViolation(failure) => handle_null_constraint_violation(
+                    self.console.clone(),
+                    failure,
+                    self.sdk_response.clone(),
+                ),
             }
         }
         Ok(())
     }
 }
 
+// DatabaseReset Handler + interactivity
+
+#[derive(Debug)]
+struct ConfirmDatabaseResetRequired {
+    sdk_response: SDKResponse,
+    loader: Addr<LoaderActor>,
+}
+
+impl ConfirmHandler for ConfirmDatabaseResetRequired {
+    fn on_confirm(&self) {
+        let tg_path = self.sdk_response.clone().typegraph_path;
+
+        // reset
+        let mut option = ServerStore::get_migration_action(&tg_path);
+        option.reset = true;
+        ServerStore::set_migration_action(tg_path.clone(), option);
+
+        // reload
+        self.loader.do_send(LoadModule(tg_path.into()));
+    }
+}
+
+async fn handle_database_reset(
+    console: Addr<ConsoleActor>,
+    loader: Addr<LoaderActor>,
+    failure: DatabaseResetRequired,
+    sdk_response: SDKResponse,
+) -> Result<()> {
+    let DatabaseResetRequired {
+        message,
+        runtime_name,
+    } = failure;
+
+    let name = sdk_response.typegraph_name.clone();
+
+    console.error(format!(
+        "Database reset required for prisma runtime {rt} in typegraph {name}",
+        rt = runtime_name.magenta(),
+    ));
+    console.error(message);
+
+    let rt = runtime_name.clone();
+    let _ = Confirm::new(
+        console,
+        format!("Do you want to reset the database for runtime {rt} on {name}?"),
+    )
+    .interact(Box::new(ConfirmDatabaseResetRequired {
+        sdk_response: sdk_response.clone(),
+        loader,
+    }))
+    .await?;
+
+    Ok(())
+}
+
+pub fn handle_null_constraint_violation(
+    console: Addr<ConsoleActor>,
+    failure: NullConstraintViolation,
+    sdk_response: SDKResponse,
+) {
+    #[allow(unused)]
+    let typegraph_name = sdk_response.typegraph_name;
+    #[allow(unused)]
+    let NullConstraintViolation {
+        message,
+        runtime_name,
+        migration_name,
+        is_new_column,
+        column,
+        table,
+    } = failure;
+
+    console.error(message);
+
+    if is_new_column {
+        console.info(format!("manually edit the migration {migration_name}; or remove the migration and add set a default value"));
+        todo!("interactive choice")
+        // let migration_dir: PathBuf = ServerStore::get_config()
+        //     .unwrap()
+        //     .prisma_migrations_dir_rel(&typegraph_name)
+        //     .join(&runtime_name)
+        //     .into();
+
+        // let remove_latest = RemoveLatestMigration {
+        //     runtime_name: runtime_name.clone(),
+        //     migration_name: migration_name.clone(),
+        //     migration_dir: migration_dir.clone(),
+        //     push_manager: self.push_manager.clone(),
+        //     console: self.console.clone(),
+        // };
+
+        // let manual = ManualResolution {
+        //     runtime_name: runtime_name.clone(),
+        //     migration_name: migration_name.clone(),
+        //     migration_dir,
+        //     message: Some(format!(
+        //         "Set a default value for the column `{}` in the table `{}`",
+        //         column, table
+        //     )),
+        //     push_manager: self.push_manager.clone(),
+        //     console: self.console.clone(),
+        // };
+
+        // let reset = ForceReset {
+        //     typegraph: typegraph.clone(),
+        //     runtime_name: runtime_name.clone(),
+        //     push_manager: self.push_manager.clone(),
+        // };
+
+        // self.push_manager
+        //     .do_send(PushFinished::new(msg.push, false).select(
+        //         "Choose one of the following options".to_string(),
+        //         vec![Box::new(remove_latest), Box::new(manual), Box::new(reset)],
+        //     ));
+    }
+}
+
 lazy_static! {
     static ref RETRY_COUNTERS: Mutex<HashMap<PathBuf, Arc<u8>>> = Mutex::new(HashMap::new());
 }
diff --git a/meta-cli/src/main.rs b/meta-cli/src/main.rs
@@ -34,8 +34,6 @@ fn main() -> Result<()> {
     setup_panic_hook();
     logger::init();
 
-    std::env::set_var("META_CLI_SERVER_PORT", get_instance_port().to_string());
-
     let _ = actix::System::with_tokio_rt(|| {
         tokio::runtime::Builder::new_multi_thread()
             .enable_all()
@@ -75,6 +73,8 @@ fn main() -> Result<()> {
                     });
                 }
                 _ => {
+                    std::env::set_var("META_CLI_SERVER_PORT", get_instance_port().to_string());
+
                     let command = command.run(args.gen);
                     let server = spawn_server().map_err(|e| e.into());
                     try_join!(command, server).unwrap_or_else(|e| {
