feat(sdk): allow MigrationAction to be configurable per runtime name

Author: michael-0acf4

examples/deploy/deploy.mjs

@@ -73,7 +73,7 @@ const tg = await typegraph({
 
 const artifactsConfig = {
   prismaMigration: {
-    action: {
+    globalAction: {
       create: true,
       reset: false
     },

examples/deploy/deploy.py

@@ -78,7 +78,8 @@ def deploy_example_python(g: Graph):
 
 config_params = MigrationConfig(
     migration_dir=path.join("prisma-migrations", tg.name),
-    action=MigrationAction(create=True, reset=True),
+    global_action=MigrationAction(create=True, reset=True),  # all runtimes
+    runtime_actions=None,  # usually set from the cli
 )
 artifacts_config = ArtifactResolutionConfig(
     prefix=None, dir=None, prisma_migration=config_params

meta-cli/src/com/server.rs

@@ -57,7 +57,22 @@ async fn config(req: HttpRequest) -> impl Responder {
 
     let endpoint = ServerStore::get_endpoint();
     let secrets = ServerStore::get_secrets();
-    let migration_action = ServerStore::get_migration_action(&parsed.typegraph_path);
+    let migration_action_glob = ServerStore::get_migration_action_glob();
+
+    let mut migration_action_per_rt = vec![];
+    if let Some(per_rt_actions) = ServerStore::get_runtime_migration_actions(&parsed.typegraph_path)
+    {
+        migration_action_per_rt =
+            per_rt_actions
+                .iter()
+                .fold(migration_action_per_rt, |mut acc, local_cfg| {
+                    acc.push(json!([
+                        local_cfg.runtime_name.clone(),
+                        local_cfg.action.clone()
+                    ]));
+                    acc
+                });
+    }
 
     let prefix = ServerStore::get_prefix();
     match ServerStore::get_config() {
@@ -76,7 +91,8 @@ async fn config(req: HttpRequest) -> impl Responder {
                     "prismaMigration": {
                         // only the cli is aware of the convention migrationDir := tg_workdir + config_folder + tg_name
                         "migrationDir": config.prisma_migrations_dir_rel(&parsed.typegraph),
-                        "action": serde_json::to_value(migration_action).unwrap()
+                        "globalAction": migration_action_glob,
+                        "runtimeAction": migration_action_per_rt
                     },
                 },
             });

meta-cli/src/com/store.rs

@@ -51,12 +51,20 @@ pub struct MigrationAction {
     pub create: bool,
 }
 
+#[derive(Default, Serialize, Clone, Debug)]
+pub struct RuntimeMigrationAction {
+    pub runtime_name: String,
+    pub action: MigrationAction,
+}
+
 #[derive(Default, Debug)]
 pub struct ServerStore {
     config: Option<Config>,
     command: Option<Command>,
+    /// default (all)
     migration_action_glob: MigrationAction,
-    migration_action: HashMap<PathBuf, Arc<MigrationAction>>,
+    /// per runtime per typegraph
+    migration_action: HashMap<PathBuf, Arc<Vec<RuntimeMigrationAction>>>,
     secrets: HashMap<String, String>,
     endpoint: Endpoint,
     prefix: Option<String>,
@@ -129,22 +137,27 @@ impl ServerStore {
         with_store(|s| s.migration_action_glob.to_owned())
     }
 
-    pub fn set_migration_action(tg_path: PathBuf, option: MigrationAction) {
+    pub fn set_migration_action(tg_path: PathBuf, rt_migration_option: RuntimeMigrationAction) {
         with_store_mut(|s| {
-            s.migration_action.insert(tg_path, option.into());
+            let mut items = vec![];
+            if let Some(actions) = s.migration_action.get(&tg_path) {
+                items = actions.as_ref().clone();
+            }
+            items.push(rt_migration_option);
+            s.migration_action.insert(tg_path, items.into());
         })
     }
 
-    pub fn get_migration_action(tg_path: &PathBuf) -> MigrationAction {
+    pub fn get_runtime_migration_actions(tg_path: &PathBuf) -> Option<Vec<RuntimeMigrationAction>> {
         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();
+                return Some(mig_action.as_ref().to_owned());
             }
-            s.migration_action_glob.to_owned()
+            None
         })
     }
 

meta-cli/src/deploy/push/migration_resolution.rs

@@ -8,7 +8,7 @@ use anyhow::Result;
 use colored::Colorize;
 
 use crate::{
-    com::store::ServerStore,
+    com::store::{MigrationAction, RuntimeMigrationAction, ServerStore},
     deploy::actors::{
         console::{
             input::{ConfirmHandler, OptionLabel, SelectOption},
@@ -24,16 +24,26 @@ use crate::{
 pub struct ConfirmDatabaseResetRequired {
     pub typegraph_path: PathBuf,
     pub loader: Addr<LoaderActor>,
+    pub runtime_name: String,
 }
 
 impl ConfirmHandler for ConfirmDatabaseResetRequired {
     fn on_confirm(&self) {
         let tg_path = self.typegraph_path.clone();
+        let runtime_name = self.runtime_name.clone();
 
         // reset
-        let mut option = ServerStore::get_migration_action(&tg_path);
-        option.reset = true;
-        ServerStore::set_migration_action(tg_path.clone(), option);
+        let glob_cfg = ServerStore::get_migration_action_glob();
+        ServerStore::set_migration_action(
+            tg_path.clone(),
+            RuntimeMigrationAction {
+                runtime_name,
+                action: MigrationAction {
+                    reset: true, // !
+                    create: glob_cfg.create,
+                },
+            },
+        );
 
         // reload
         self.loader.do_send(LoadModule(tg_path.into()));

meta-cli/src/deploy/push/pusher.rs

@@ -235,6 +235,7 @@ async fn handle_database_reset(
     )
     .interact(Box::new(ConfirmDatabaseResetRequired {
         typegraph_path: sdk_response.typegraph_path,
+        runtime_name,
         loader,
     }))
     .await?;

typegraph/core/src/utils/postprocess/prisma_rt.rs

@@ -8,8 +8,8 @@ use common::typegraph::Typegraph;
 
 use crate::utils::fs_host;
 use crate::utils::postprocess::PostProcessor;
-use crate::wit::core::MigrationConfig;
-use crate::wit::metatype::typegraph::host::path_exists;
+use crate::wit::core::{MigrationAction, MigrationConfig};
+use crate::wit::metatype::typegraph::host::{eprint, path_exists};
 
 pub struct PrismaProcessor {
     config: MigrationConfig,
@@ -36,6 +36,7 @@ impl PrismaProcessor {
             if let TGRuntime::Known(Prisma(rt_data)) = rt {
                 let rt_name = &rt_data.name;
                 let path = base_migration_path.join(rt_name);
+                let action = self.get_action_by_rt_name(rt_name);
 
                 rt_data.migration_options = Some(MigrationOptions {
                     migration_files: {
@@ -48,8 +49,8 @@ impl PrismaProcessor {
                             false => None,
                         }
                     },
-                    create: self.config.action.create,
-                    reset: self.config.action.reset,
+                    create: action.create,
+                    reset: action.reset,
                 });
             }
         }
@@ -62,4 +63,16 @@ impl PrismaProcessor {
         let path = fs_host::cwd()?.join(PathBuf::from(migration_dir));
         Ok(path)
     }
+
+    /// Get migration action from runtime_name (usually set from the cli)
+    /// If nothing is found, find the global action config (set initially)
+    pub fn get_action_by_rt_name(&self, name: &str) -> MigrationAction {
+        if let Some(actions) = self.config.runtime_actions.clone() {
+            if let Some(action) = actions.iter().find(|(rt, _)| rt.eq(name)) {
+                eprint(&format!("Specific migration action found for {name}"));
+                return action.1;
+            }
+        }
+        self.config.global_action
+    }
 }

typegraph/core/wit/typegraph.wit

@@ -42,7 +42,8 @@ interface core {
 
     record migration-config {
         migration-dir: string,
-        action: migration-action
+        global-action: migration-action, // global config (all runtimes)
+        runtime-actions: option<list<tuple<string, migration-action>>> // config per runtime name (override global-action)
     }
 
     record artifact-resolution-config {

typegraph/python/typegraph/graph/tg_manage.py

@@ -142,6 +142,8 @@ def request_config(self) -> CLIConfigRequest:
             auth = BasicAuth(raw_auth["username"], raw_auth["password"])
 
         artifact_config_raw = cli_res["artifactsConfig"]
+        migration_action_raw = artifact_config_raw["prismaMigration"]
+
         return CLIConfigRequest(
             typegate=Typegate(endpoint=cli_res["typegate"]["endpoint"], auth=auth),
             prefix=prefix,
@@ -150,12 +152,13 @@ def request_config(self) -> CLIConfigRequest:
                 dir=artifact_config_raw["dir"],
                 prefix=prefix,
                 prisma_migration=MigrationConfig(
-                    action=MigrationAction(
-                        create=artifact_config_raw["prismaMigration"]["action"][
-                            "create"
-                        ],
-                        reset=artifact_config_raw["prismaMigration"]["action"]["reset"],
+                    global_action=json_to_mig_action(
+                        migration_action_raw["globalAction"]
                     ),
+                    runtime_actions=[
+                        (rt, json_to_mig_action(act))
+                        for [rt, act] in migration_action_raw["runtimeAction"]
+                    ],
                     migration_dir=artifact_config_raw["prismaMigration"][
                         "migrationDir"
                     ],
@@ -174,7 +177,6 @@ def relay_result_to_cli(self, initiator: Command, fn: callable):
             response["data"] = json.loads(res) if isinstance(res, str) else res
         except Exception as e:
             response["error"] = str(e)
-
         req = request.Request(
             url=f"{self.endpoint}/response",
             method="POST",
@@ -189,3 +191,10 @@ def exist_and_not_null(obj: dict, field: str):
     if field in obj:
         return obj[field] is not None
     return False
+
+
+def json_to_mig_action(obj: dict) -> MigrationAction:
+    return MigrationAction(
+        create=obj["create"],
+        reset=obj["reset"],
+    )

typegraph/python/typegraph/graph/typegraph.py

@@ -78,7 +78,6 @@ def expose(
         default_policy: Optional[PolicySpec] = None,
         **kwargs: ExposeItem,
     ):
-        print(str(kwargs))
         res = core.expose(
             store,
             [(k, v.id) for k, v in kwargs.items()],