ci: fix broken validation due to version mismatch (#303)

Author: jahvon

.execs/validate.flow

@@ -30,6 +30,8 @@ executables:
           echo ""
           echo "Uncommitted changes:"
           git status --porcelain
+          echo "Difference:"
+          git --no-pager diff
           exit 1
         else
           echo "✅ All generated files are up to date"

.github/workflows/ci.yaml

@@ -81,6 +81,7 @@ jobs:
   coverage:
     needs: [unit-tests, e2e-tests]
     runs-on: ubuntu-latest
+    if: github.actor != 'dependabot[bot]'
     steps:
       - uses: actions/checkout@v4
       - name: Download unit test coverage

desktop/scripts/generate-rust-types.sh

@@ -18,7 +18,7 @@ generate_schema() {
 
     if ! cargo typify --version &>/dev/null; then
         echo -e "Installing cargo-typify..."
-        cargo install cargo-typify
+        cargo install cargo-typify@0.4.3
     fi
 
     if cargo typify "$schema_path" --output "$output_file"; then

desktop/src-tauri/src/types/generated/config.rs

@@ -366,12 +366,12 @@ impl ::std::convert::From<&Self> for ConfigTheme {
 impl ::std::fmt::Display for ConfigTheme {
     fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
         match *self {
-            Self::Default => write!(f, "default"),
-            Self::Everforest => write!(f, "everforest"),
-            Self::Dark => write!(f, "dark"),
-            Self::Light => write!(f, "light"),
-            Self::Dracula => write!(f, "dracula"),
-            Self::TokyoNight => write!(f, "tokyo-night"),
+            Self::Default => f.write_str("default"),
+            Self::Everforest => f.write_str("everforest"),
+            Self::Dark => f.write_str("dark"),
+            Self::Light => f.write_str("light"),
+            Self::Dracula => f.write_str("dracula"),
+            Self::TokyoNight => f.write_str("tokyo-night"),
         }
     }
 }
@@ -458,8 +458,8 @@ impl ::std::convert::From<&Self> for ConfigWorkspaceMode {
 impl ::std::fmt::Display for ConfigWorkspaceMode {
     fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
         match *self {
-            Self::Fixed => write!(f, "fixed"),
-            Self::Dynamic => write!(f, "dynamic"),
+            Self::Fixed => f.write_str("fixed"),
+            Self::Dynamic => f.write_str("dynamic"),
         }
     }
 }

desktop/src-tauri/src/types/generated/flowfile.rs

@@ -153,10 +153,10 @@ impl ::std::convert::From<&Self> for CommonVisibility {
 impl ::std::fmt::Display for CommonVisibility {
     fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
         match *self {
-            Self::Public => write!(f, "public"),
-            Self::Private => write!(f, "private"),
-            Self::Internal => write!(f, "internal"),
-            Self::Hidden => write!(f, "hidden"),
+            Self::Public => f.write_str("public"),
+            Self::Private => f.write_str("private"),
+            Self::Internal => f.write_str("internal"),
+            Self::Hidden => f.write_str("hidden"),
         }
     }
 }
@@ -503,10 +503,10 @@ impl ::std::convert::From<&Self> for ExecutableArgumentType {
 impl ::std::fmt::Display for ExecutableArgumentType {
     fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
         match *self {
-            Self::String => write!(f, "string"),
-            Self::Int => write!(f, "int"),
-            Self::Float => write!(f, "float"),
-            Self::Bool => write!(f, "bool"),
+            Self::String => f.write_str("string"),
+            Self::Int => f.write_str("int"),
+            Self::Float => f.write_str("float"),
+            Self::Bool => f.write_str("bool"),
         }
     }
 }
@@ -1357,11 +1357,11 @@ impl ::std::convert::From<&Self> for ExecutableRequestExecutableTypeMethod {
 impl ::std::fmt::Display for ExecutableRequestExecutableTypeMethod {
     fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
         match *self {
-            Self::Get => write!(f, "GET"),
-            Self::Post => write!(f, "POST"),
-            Self::Put => write!(f, "PUT"),
-            Self::Patch => write!(f, "PATCH"),
-            Self::Delete => write!(f, "DELETE"),
+            Self::Get => f.write_str("GET"),
+            Self::Post => f.write_str("POST"),
+            Self::Put => f.write_str("PUT"),
+            Self::Patch => f.write_str("PATCH"),
+            Self::Delete => f.write_str("DELETE"),
         }
     }
 }
@@ -1516,11 +1516,11 @@ impl ::std::convert::From<&Self> for ExecutableRequestResponseFileSaveAs {
 impl ::std::fmt::Display for ExecutableRequestResponseFileSaveAs {
     fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
         match *self {
-            Self::Raw => write!(f, "raw"),
-            Self::Json => write!(f, "json"),
-            Self::IndentedJson => write!(f, "indented-json"),
-            Self::Yaml => write!(f, "yaml"),
-            Self::Yml => write!(f, "yml"),
+            Self::Raw => f.write_str("raw"),
+            Self::Json => f.write_str("json"),
+            Self::IndentedJson => f.write_str("indented-json"),
+            Self::Yaml => f.write_str("yaml"),
+            Self::Yml => f.write_str("yml"),
         }
     }
 }
@@ -2171,132 +2171,132 @@ impl ::std::convert::From<&Self> for ExecutableVerb {
 impl ::std::fmt::Display for ExecutableVerb {
     fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
         match *self {
-            Self::Abort => write!(f, "abort"),
-            Self::Activate => write!(f, "activate"),
-            Self::Add => write!(f, "add"),
-            Self::Analyze => write!(f, "analyze"),
-            Self::Apply => write!(f, "apply"),
-            Self::Archive => write!(f, "archive"),
-            Self::Audit => write!(f, "audit"),
-            Self::Backup => write!(f, "backup"),
-            Self::Benchmark => write!(f, "benchmark"),
-            Self::Build => write!(f, "build"),
-            Self::Bundle => write!(f, "bundle"),
-            Self::Check => write!(f, "check"),
-            Self::Clean => write!(f, "clean"),
-            Self::Clear => write!(f, "clear"),
-            Self::Commit => write!(f, "commit"),
-            Self::Compile => write!(f, "compile"),
-            Self::Compress => write!(f, "compress"),
-            Self::Configure => write!(f, "configure"),
-            Self::Connect => write!(f, "connect"),
-            Self::Copy => write!(f, "copy"),
-            Self::Create => write!(f, "create"),
-            Self::Deactivate => write!(f, "deactivate"),
-            Self::Debug => write!(f, "debug"),
-            Self::Decompress => write!(f, "decompress"),
-            Self::Decrypt => write!(f, "decrypt"),
-            Self::Delete => write!(f, "delete"),
-            Self::Deploy => write!(f, "deploy"),
-            Self::Destroy => write!(f, "destroy"),
-            Self::Disable => write!(f, "disable"),
-            Self::Disconnect => write!(f, "disconnect"),
-            Self::Edit => write!(f, "edit"),
-            Self::Enable => write!(f, "enable"),
-            Self::Encrypt => write!(f, "encrypt"),
-            Self::Erase => write!(f, "erase"),
-            Self::Exec => write!(f, "exec"),
-            Self::Execute => write!(f, "execute"),
-            Self::Export => write!(f, "export"),
-            Self::Expose => write!(f, "expose"),
-            Self::Fetch => write!(f, "fetch"),
-            Self::Fix => write!(f, "fix"),
-            Self::Flush => write!(f, "flush"),
-            Self::Format => write!(f, "format"),
-            Self::Generate => write!(f, "generate"),
-            Self::Get => write!(f, "get"),
-            Self::Import => write!(f, "import"),
-            Self::Index => write!(f, "index"),
-            Self::Init => write!(f, "init"),
-            Self::Inspect => write!(f, "inspect"),
-            Self::Install => write!(f, "install"),
-            Self::Join => write!(f, "join"),
-            Self::Kill => write!(f, "kill"),
-            Self::Launch => write!(f, "launch"),
-            Self::Lint => write!(f, "lint"),
-            Self::List => write!(f, "list"),
-            Self::Load => write!(f, "load"),
-            Self::Lock => write!(f, "lock"),
-            Self::Login => write!(f, "login"),
-            Self::Logout => write!(f, "logout"),
-            Self::Manage => write!(f, "manage"),
-            Self::Merge => write!(f, "merge"),
-            Self::Migrate => write!(f, "migrate"),
-            Self::Modify => write!(f, "modify"),
-            Self::Monitor => write!(f, "monitor"),
-            Self::Mount => write!(f, "mount"),
-            Self::New => write!(f, "new"),
-            Self::Notify => write!(f, "notify"),
-            Self::Open => write!(f, "open"),
-            Self::Package => write!(f, "package"),
-            Self::Partition => write!(f, "partition"),
-            Self::Patch => write!(f, "patch"),
-            Self::Pause => write!(f, "pause"),
-            Self::Ping => write!(f, "ping"),
-            Self::Preload => write!(f, "preload"),
-            Self::Prefetch => write!(f, "prefetch"),
-            Self::Profile => write!(f, "profile"),
-            Self::Provision => write!(f, "provision"),
-            Self::Publish => write!(f, "publish"),
-            Self::Purge => write!(f, "purge"),
-            Self::Push => write!(f, "push"),
-            Self::Queue => write!(f, "queue"),
-            Self::Reboot => write!(f, "reboot"),
-            Self::Recover => write!(f, "recover"),
-            Self::Refresh => write!(f, "refresh"),
-            Self::Release => write!(f, "release"),
-            Self::Reload => write!(f, "reload"),
-            Self::Remove => write!(f, "remove"),
-            Self::Request => write!(f, "request"),
-            Self::Reset => write!(f, "reset"),
-            Self::Restart => write!(f, "restart"),
-            Self::Restore => write!(f, "restore"),
-            Self::Retrieve => write!(f, "retrieve"),
-            Self::Rollback => write!(f, "rollback"),
-            Self::Run => write!(f, "run"),
-            Self::Save => write!(f, "save"),
-            Self::Scale => write!(f, "scale"),
-            Self::Scan => write!(f, "scan"),
-            Self::Schedule => write!(f, "schedule"),
-            Self::Seed => write!(f, "seed"),
-            Self::Send => write!(f, "send"),
-            Self::Serve => write!(f, "serve"),
-            Self::Set => write!(f, "set"),
-            Self::Setup => write!(f, "setup"),
-            Self::Show => write!(f, "show"),
-            Self::Snapshot => write!(f, "snapshot"),
-            Self::Start => write!(f, "start"),
-            Self::Stash => write!(f, "stash"),
-            Self::Stop => write!(f, "stop"),
-            Self::Tag => write!(f, "tag"),
-            Self::Teardown => write!(f, "teardown"),
-            Self::Terminate => write!(f, "terminate"),
-            Self::Test => write!(f, "test"),
-            Self::Tidy => write!(f, "tidy"),
-            Self::Trace => write!(f, "trace"),
-            Self::Transform => write!(f, "transform"),
-            Self::Trigger => write!(f, "trigger"),
-            Self::Tunnel => write!(f, "tunnel"),
-            Self::Undeploy => write!(f, "undeploy"),
-            Self::Uninstall => write!(f, "uninstall"),
-            Self::Unmount => write!(f, "unmount"),
-            Self::Unset => write!(f, "unset"),
-            Self::Update => write!(f, "update"),
-            Self::Upgrade => write!(f, "upgrade"),
-            Self::Validate => write!(f, "validate"),
-            Self::Verify => write!(f, "verify"),
-            Self::View => write!(f, "view"),
-            Self::Watch => write!(f, "watch"),
+            Self::Abort => f.write_str("abort"),
+            Self::Activate => f.write_str("activate"),
+            Self::Add => f.write_str("add"),
+            Self::Analyze => f.write_str("analyze"),
+            Self::Apply => f.write_str("apply"),
+            Self::Archive => f.write_str("archive"),
+            Self::Audit => f.write_str("audit"),
+            Self::Backup => f.write_str("backup"),
+            Self::Benchmark => f.write_str("benchmark"),
+            Self::Build => f.write_str("build"),
+            Self::Bundle => f.write_str("bundle"),
+            Self::Check => f.write_str("check"),
+            Self::Clean => f.write_str("clean"),
+            Self::Clear => f.write_str("clear"),
+            Self::Commit => f.write_str("commit"),
+            Self::Compile => f.write_str("compile"),
+            Self::Compress => f.write_str("compress"),
+            Self::Configure => f.write_str("configure"),
+            Self::Connect => f.write_str("connect"),
+            Self::Copy => f.write_str("copy"),
+            Self::Create => f.write_str("create"),
+            Self::Deactivate => f.write_str("deactivate"),
+            Self::Debug => f.write_str("debug"),
+            Self::Decompress => f.write_str("decompress"),
+            Self::Decrypt => f.write_str("decrypt"),
+            Self::Delete => f.write_str("delete"),
+            Self::Deploy => f.write_str("deploy"),
+            Self::Destroy => f.write_str("destroy"),
+            Self::Disable => f.write_str("disable"),
+            Self::Disconnect => f.write_str("disconnect"),
+            Self::Edit => f.write_str("edit"),
+            Self::Enable => f.write_str("enable"),
+            Self::Encrypt => f.write_str("encrypt"),
+            Self::Erase => f.write_str("erase"),
+            Self::Exec => f.write_str("exec"),
+            Self::Execute => f.write_str("execute"),
+            Self::Export => f.write_str("export"),
+            Self::Expose => f.write_str("expose"),
+            Self::Fetch => f.write_str("fetch"),
+            Self::Fix => f.write_str("fix"),
+            Self::Flush => f.write_str("flush"),
+            Self::Format => f.write_str("format"),
+            Self::Generate => f.write_str("generate"),
+            Self::Get => f.write_str("get"),
+            Self::Import => f.write_str("import"),
+            Self::Index => f.write_str("index"),
+            Self::Init => f.write_str("init"),
+            Self::Inspect => f.write_str("inspect"),
+            Self::Install => f.write_str("install"),
+            Self::Join => f.write_str("join"),
+            Self::Kill => f.write_str("kill"),
+            Self::Launch => f.write_str("launch"),
+            Self::Lint => f.write_str("lint"),
+            Self::List => f.write_str("list"),
+            Self::Load => f.write_str("load"),
+            Self::Lock => f.write_str("lock"),
+            Self::Login => f.write_str("login"),
+            Self::Logout => f.write_str("logout"),
+            Self::Manage => f.write_str("manage"),
+            Self::Merge => f.write_str("merge"),
+            Self::Migrate => f.write_str("migrate"),
+            Self::Modify => f.write_str("modify"),
+            Self::Monitor => f.write_str("monitor"),
+            Self::Mount => f.write_str("mount"),
+            Self::New => f.write_str("new"),
+            Self::Notify => f.write_str("notify"),
+            Self::Open => f.write_str("open"),
+            Self::Package => f.write_str("package"),
+            Self::Partition => f.write_str("partition"),
+            Self::Patch => f.write_str("patch"),
+            Self::Pause => f.write_str("pause"),
+            Self::Ping => f.write_str("ping"),
+            Self::Preload => f.write_str("preload"),
+            Self::Prefetch => f.write_str("prefetch"),
+            Self::Profile => f.write_str("profile"),
+            Self::Provision => f.write_str("provision"),
+            Self::Publish => f.write_str("publish"),
+            Self::Purge => f.write_str("purge"),
+            Self::Push => f.write_str("push"),
+            Self::Queue => f.write_str("queue"),
+            Self::Reboot => f.write_str("reboot"),
+            Self::Recover => f.write_str("recover"),
+            Self::Refresh => f.write_str("refresh"),
+            Self::Release => f.write_str("release"),
+            Self::Reload => f.write_str("reload"),
+            Self::Remove => f.write_str("remove"),
+            Self::Request => f.write_str("request"),
+            Self::Reset => f.write_str("reset"),
+            Self::Restart => f.write_str("restart"),
+            Self::Restore => f.write_str("restore"),
+            Self::Retrieve => f.write_str("retrieve"),
+            Self::Rollback => f.write_str("rollback"),
+            Self::Run => f.write_str("run"),
+            Self::Save => f.write_str("save"),
+            Self::Scale => f.write_str("scale"),
+            Self::Scan => f.write_str("scan"),
+            Self::Schedule => f.write_str("schedule"),
+            Self::Seed => f.write_str("seed"),
+            Self::Send => f.write_str("send"),
+            Self::Serve => f.write_str("serve"),
+            Self::Set => f.write_str("set"),
+            Self::Setup => f.write_str("setup"),
+            Self::Show => f.write_str("show"),
+            Self::Snapshot => f.write_str("snapshot"),
+            Self::Start => f.write_str("start"),
+            Self::Stash => f.write_str("stash"),
+            Self::Stop => f.write_str("stop"),
+            Self::Tag => f.write_str("tag"),
+            Self::Teardown => f.write_str("teardown"),
+            Self::Terminate => f.write_str("terminate"),
+            Self::Test => f.write_str("test"),
+            Self::Tidy => f.write_str("tidy"),
+            Self::Trace => f.write_str("trace"),
+            Self::Transform => f.write_str("transform"),
+            Self::Trigger => f.write_str("trigger"),
+            Self::Tunnel => f.write_str("tunnel"),
+            Self::Undeploy => f.write_str("undeploy"),
+            Self::Uninstall => f.write_str("uninstall"),
+            Self::Unmount => f.write_str("unmount"),
+            Self::Unset => f.write_str("unset"),
+            Self::Update => f.write_str("update"),
+            Self::Upgrade => f.write_str("upgrade"),
+            Self::Validate => f.write_str("validate"),
+            Self::Verify => f.write_str("verify"),
+            Self::View => f.write_str("view"),
+            Self::Watch => f.write_str("watch"),
         }
     }
 }

desktop/src-tauri/src/types/generated/template.rs

@@ -305,10 +305,10 @@ impl ::std::convert::From<&Self> for FieldType {
 impl ::std::fmt::Display for FieldType {
     fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
         match *self {
-            Self::Text => write!(f, "text"),
-            Self::Masked => write!(f, "masked"),
-            Self::Multiline => write!(f, "multiline"),
-            Self::Confirm => write!(f, "confirm"),
+            Self::Text => f.write_str("text"),
+            Self::Masked => f.write_str("masked"),
+            Self::Multiline => f.write_str("multiline"),
+            Self::Confirm => f.write_str("confirm"),
         }
     }
 }