flowey: use typestate pattern for gh variables

flowey/flowey_cli/src/cli/debug/interrogate.rs

@@ -2,6 +2,7 @@
 // Licensed under the MIT License.
 
 use crate::cli::FlowBackendCli;
+use flowey_core::github_context::GhVarState;
 use flowey_core::node::steps::rust::RustRuntimeServices;
 use flowey_core::node::user_facing::ClaimedGhParam;
 use flowey_core::node::user_facing::GhPermission;
@@ -168,10 +169,10 @@ impl flowey_core::node::NodeCtxBackend for InterrogateCtx {
         _uses: &str,
         _with: BTreeMap<String, ClaimedGhParam>,
         _condvar: Option<String>,
-        _outputs: BTreeMap<String, Vec<(String, bool)>>,
+        _outputs: BTreeMap<String, Vec<(String, bool, bool)>>,
         _permissions: BTreeMap<GhPermission, GhPermissionValue>,
-        _gh_to_rust: Vec<(String, String, bool)>,
-        _rust_to_gh: Vec<(String, String, bool)>,
+        _gh_to_rust: Vec<GhVarState>,
+        _rust_to_gh: Vec<GhVarState>,
     ) {
         println!("[step][yaml]    # {}", label);
         self.idx_tracker += 1;

flowey/flowey_cli/src/cli/exec_snippet.rs

@@ -3,6 +3,7 @@
 
 use crate::cli::FlowBackendCli;
 use anyhow::Context;
+use flowey_core::github_context::GhVarState;
 use flowey_core::node::steps::rust::RustRuntimeServices;
 use flowey_core::node::user_facing::ClaimedGhParam;
 use flowey_core::node::user_facing::GhPermission;
@@ -310,10 +311,10 @@ impl flowey_core::node::NodeCtxBackend for ExecSnippetCtx<'_, '_> {
         _uses: &str,
         _with: BTreeMap<String, ClaimedGhParam>,
         _condvar: Option<String>,
-        _outputs: BTreeMap<String, Vec<(String, bool)>>,
+        _outputs: BTreeMap<String, Vec<(String, bool, bool)>>,
         _permissions: BTreeMap<GhPermission, GhPermissionValue>,
-        _gh_to_rust: Vec<(String, String, bool)>,
-        _rust_to_gh: Vec<(String, String, bool)>,
+        _gh_to_rust: Vec<GhVarState>,
+        _rust_to_gh: Vec<GhVarState>,
     ) {
         self.idx_tracker += 1;
     }

flowey/flowey_cli/src/flow_resolver/stage1_dag.rs

@@ -2,6 +2,7 @@
 // Licensed under the MIT License.
 
 use anyhow::Context;
+use flowey_core::github_context::GhVarState;
 use flowey_core::node::read_var_internals;
 use flowey_core::node::steps::rust::RustRuntimeServices;
 use flowey_core::node::user_facing::ClaimedGhParam;
@@ -599,8 +600,8 @@ pub(crate) enum Step {
         >,
     },
     GitHubYaml {
-        gh_to_rust: Vec<(String, String, bool)>,
-        rust_to_gh: Vec<(String, String, bool)>,
+        gh_to_rust: Vec<GhVarState>,
+        rust_to_gh: Vec<GhVarState>,
         label: String,
         step_id: String,
         uses: String,
@@ -779,10 +780,10 @@ impl flowey_core::node::NodeCtxBackend for EmitFlowCtx<'_> {
         uses: &str,
         with: BTreeMap<String, ClaimedGhParam>,
         condvar: Option<String>,
-        outputs: BTreeMap<String, Vec<(String, bool)>>,
+        outputs: BTreeMap<String, Vec<(String, bool, bool)>>,
         permissions: BTreeMap<GhPermission, GhPermissionValue>,
-        mut gh_to_rust: Vec<(String, String, bool)>,
-        mut rust_to_gh: Vec<(String, String, bool)>,
+        mut gh_to_rust: Vec<GhVarState>,
+        mut rust_to_gh: Vec<GhVarState>,
     ) {
         let mut fresh_yaml_var = || {
             *self.yaml_var_ordinal += 1;
@@ -806,7 +807,12 @@ impl flowey_core::node::NodeCtxBackend for EmitFlowCtx<'_> {
                     let (backing_var, is_secret) = read_var_internals(&v);
                     let backing_var = backing_var.unwrap();
                     let new_gh_var_name = fresh_yaml_var();
-                    rust_to_gh.push((backing_var.clone(), new_gh_var_name.clone(), is_secret));
+                    rust_to_gh.push(GhVarState {
+                        backing_var: backing_var.clone(),
+                        raw_name: new_gh_var_name.clone(),
+                        is_object: false,
+                        is_secret,
+                    });
                     (k, format!("${{{{ env.{} }}}}", new_gh_var_name))
                 }
             })
@@ -815,7 +821,12 @@ impl flowey_core::node::NodeCtxBackend for EmitFlowCtx<'_> {
         for (name, output_vars) in outputs {
             for output in output_vars {
                 let gh_context_var_name = format!("steps.{step_id}.outputs.{name}");
-                gh_to_rust.push((gh_context_var_name, output.0, output.1));
+                gh_to_rust.push(GhVarState {
+                    backing_var: output.0,
+                    raw_name: gh_context_var_name,
+                    is_secret: output.1,
+                    is_object: output.2,
+                });
             }
         }
 

flowey/flowey_cli/src/pipeline_resolver/github_yaml/mod.rs

@@ -836,20 +836,28 @@ fn resolve_flow_as_github_yaml_steps(
                     output_steps.push(map.into());
                 }
 
-                for (rust_var, gh_var, is_secret) in rust_to_gh {
+                for gh_var_state in rust_to_gh {
                     let mut cmd = String::new();
 
                     // flowey considers all GitHub vars to be typed as raw strings
-                    let set_gh_env_var =
-                        var_db_cmd(&rust_var, is_secret, None, true, Some(gh_var.clone()));
+                    let set_gh_env_var = var_db_cmd(
+                        &gh_var_state.backing_var,
+                        gh_var_state.is_secret,
+                        None,
+                        !gh_var_state.is_object,
+                        Some(gh_var_state.raw_name.clone()),
+                    );
                     writeln!(cmd, r#"{set_gh_env_var}"#)?;
 
                     let mut map = serde_yaml::Mapping::new();
                     map.insert("run".into(), serde_yaml::Value::String(cmd));
                     map.insert("shell".into(), "bash".into());
                     map.insert(
                         "name".into(),
-                        serde_yaml::Value::String(format!("🌼 Write to '{gh_var}'")),
+                        serde_yaml::Value::String(format!(
+                            "🌼 Write to '{}'",
+                            gh_var_state.raw_name
+                        )),
                     );
 
                     if condvar.is_some() {
@@ -878,17 +886,30 @@ fn resolve_flow_as_github_yaml_steps(
                     output_steps.push(step);
                 }
 
-                for (gh_var, rust_var, is_secret) in gh_to_rust {
+                for gh_var_state in gh_to_rust {
                     // flowey considers all GitHub vars to be typed as raw strings
-                    let write_rust_var = var_db_cmd(&rust_var, is_secret, Some("{0}"), true, None);
-                    let cmd = format!(r#"${{{{ {gh_var} }}}}"#);
+                    let write_rust_var = var_db_cmd(
+                        &gh_var_state.backing_var,
+                        gh_var_state.is_secret,
+                        Some("{0}"),
+                        !gh_var_state.is_object,
+                        None,
+                    );
+                    let cmd = if gh_var_state.is_object {
+                        format!(r#"${{{{ toJSON({}) }}}}"#, gh_var_state.raw_name)
+                    } else {
+                        format!(r#"${{{{ {} }}}}"#, gh_var_state.raw_name)
+                    };
 
                     let mut map = serde_yaml::Mapping::new();
                     map.insert("run".into(), serde_yaml::Value::String(cmd));
                     map.insert("shell".into(), write_rust_var.into());
                     map.insert(
                         "name".into(),
-                        serde_yaml::Value::String(format!("🌼 Read from '{gh_var}'")),
+                        serde_yaml::Value::String(format!(
+                            "🌼 Read from '{}'",
+                            gh_var_state.raw_name
+                        )),
                     );
                     if condvar.is_some() {
                         map.insert("if".into(), "${{ fromJSON(env.FLOWEY_CONDITION) }}".into());

flowey/flowey_core/src/github_context.rs

@@ -0,0 +1,87 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+//! Core types and traits used to read GitHub context variables.
+
+use crate::node::{user_facing::GhContextVar, ClaimVar, NodeCtx, ReadVar, StepCtx};
+use serde::{de::DeserializeOwned, Deserialize, Serialize};
+use std::collections::BTreeMap;
+
+#[derive(Serialize, Deserialize)]
+pub struct Head {
+    #[serde(rename = "ref")]
+    pub head_ref: String,
+}
+
+#[derive(Serialize, Deserialize)]
+pub struct GhContextVarReaderEventPullRequest {
+    pub head: Head,
+}
+
+pub enum Root {}
+pub enum Event {}
+
+#[derive(Clone)]
+pub struct GhVarState {
+    pub raw_name: String,
+    pub backing_var: String,
+    pub is_secret: bool,
+    pub is_object: bool,
+}
+
+pub struct GhContextVarReader<'a, S> {
+    pub ctx: NodeCtx<'a>,
+    pub _state: std::marker::PhantomData<S>,
+}
+
+impl<S> GhContextVarReader<'_, S> {
+    fn read_var<T: Serialize + DeserializeOwned>(
+        &self,
+        var_name: String,
+        is_secret: bool,
+        is_object: bool,
+    ) -> ReadVar<T> {
+        let (var, write_var) = self.ctx.new_maybe_secret_var(is_secret, "");
+        let write_var = write_var.claim(&mut StepCtx {
+            backend: self.ctx.backend.clone(),
+        });
+        let var_state = GhVarState {
+            raw_name: var_name.clone(),
+            backing_var: write_var.backing_var,
+            is_secret: write_var.is_secret,
+            is_object,
+        };
+        let gh_to_rust = vec![var_state];
+
+        self.ctx.backend.borrow_mut().on_emit_gh_step(
+            &format!("🌼 read {}", var_name),
+            "",
+            BTreeMap::new(),
+            None,
+            BTreeMap::new(),
+            BTreeMap::new(),
+            gh_to_rust,
+            Vec::new(),
+        );
+        var
+    }
+}
+
+impl<'a> GhContextVarReader<'a, Root> {
+    pub fn global(&self, gh_var: GhContextVar) -> ReadVar<String> {
+        self.read_var(gh_var.as_raw_var_name(), gh_var.is_secret(), false)
+    }
+
+    pub fn event(self) -> GhContextVarReader<'a, Event> {
+        GhContextVarReader {
+            ctx: self.ctx,
+            _state: std::marker::PhantomData,
+        }
+    }
+}
+
+impl GhContextVarReader<'_, Event> {
+    pub fn pull_request(self) -> ReadVar<Option<GhContextVarReaderEventPullRequest>> {
+        self.read_var("github.event.pull_request".to_string(), false, true)
+    }
+}

flowey/flowey_core/src/lib.rs

@@ -7,6 +7,7 @@
 //! this crate!** The crate you should be using is called `flowey`, which only
 //! exports user-facing types / traits.
 
+pub mod github_context;
 pub mod node;
 pub mod patch;
 pub mod pipeline;