Ensure four-star CLI can handle all types from OpenAPI spec (#440)

Author: notpeter

Cargo.lock

@@ -28,5 +28,11 @@ tokio = { workspace = true, features = ["rt-multi-thread", "macros"] }
 toml = { workspace = true }
 uuid = { workspace = true, features = ["serde", "v4"] }
 
+[build-dependencies]
+serde_json = { workspace = true }
+
+[dev-dependencies]
+regex = { workspace = true }
+
 [package.metadata.dist]
 targets = ["x86_64-unknown-linux-gnu", "aarch64-apple-darwin", "x86_64-apple-darwin"]

rfd-cli/Cargo.toml

@@ -0,0 +1,112 @@
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v. 2.0. If a copy of the MPL was not distributed with this
+// file, You can obtain one at https://mozilla.org/MPL/2.0/.
+
+// Reads `rfd-api-spec.json` and emits `expected_response_types.rs`
+// containing a function that returns the schemars schema name for every JSON
+// response type the API can produce. The generated source references real
+// types from `rfd_sdk::types`, so a renamed/removed type breaks the build
+// instead of silently slipping past the dispatch coverage test.
+
+use serde_json::Value;
+use std::collections::BTreeSet;
+use std::env;
+use std::fs;
+use std::path::Path;
+
+fn main() {
+    let spec_path = "../rfd-api-spec.json";
+    println!("cargo:rerun-if-changed=build.rs");
+    println!("cargo:rerun-if-changed={spec_path}");
+
+    let spec_text =
+        fs::read_to_string(spec_path).unwrap_or_else(|e| panic!("read {spec_path}: {e}"));
+    let spec: Value = serde_json::from_str(&spec_text).expect("parse spec JSON");
+
+    let entries = collect_entries(&spec);
+
+    let mut src = String::from(
+        "// AUTO-GENERATED by build.rs — do not edit.\n\
+         pub fn expected_response_schema_names() -> Vec<String> {\n    vec![\n",
+    );
+    for entry in &entries {
+        src.push_str("        ");
+        src.push_str(entry);
+        src.push_str(",\n");
+    }
+    src.push_str("    ]\n}\n");
+
+    let out_dir = env::var_os("OUT_DIR").expect("OUT_DIR set by cargo");
+    let dest = Path::new(&out_dir).join("expected_response_types.rs");
+    fs::write(&dest, src).expect("write expected_response_types.rs");
+}
+
+fn collect_entries(spec: &Value) -> Vec<String> {
+    let mut entries: BTreeSet<String> = BTreeSet::new();
+    let Some(paths) = spec.get("paths").and_then(Value::as_object) else {
+        return Vec::new();
+    };
+    for ops in paths.values() {
+        let Some(ops) = ops.as_object() else { continue };
+        for op in ops.values() {
+            let Some(responses) = op.get("responses").and_then(Value::as_object) else {
+                continue;
+            };
+            for (status, resp) in responses {
+                if !status.starts_with('2') {
+                    continue;
+                }
+                let Some(schema) = resp.pointer("/content/application~1json/schema") else {
+                    continue;
+                };
+                if let Some(entry) = schema_to_entry(schema) {
+                    entries.insert(entry);
+                }
+            }
+        }
+    }
+    entries.into_iter().collect()
+}
+
+fn schema_to_entry(schema: &Value) -> Option<String> {
+    if let Some(r) = schema.get("$ref").and_then(Value::as_str) {
+        let rust = strip_underscores(&ref_tail(r));
+        return Some(format!(
+            "<rfd_sdk::types::{rust} as schemars::JsonSchema>::schema_name()"
+        ));
+    }
+    if schema.get("type").and_then(Value::as_str) == Some("array") {
+        if let Some(r) = schema.pointer("/items/$ref").and_then(Value::as_str) {
+            let rust = strip_underscores(&ref_tail(r));
+            return Some(format!(
+                "<Vec<rfd_sdk::types::{rust}> as schemars::JsonSchema>::schema_name()"
+            ));
+        }
+        // Inline arrays without a `$ref` items target (e.g. `Vec<u8>`) have no
+        // matching `rfd_sdk::types::*` to reference. The dispatch table is not
+        // expected to cover them, so we skip rather than emit.
+    }
+    None
+}
+
+fn ref_tail(r: &str) -> String {
+    r.rsplit('/').next().unwrap_or_default().to_string()
+}
+
+/// Translate an OpenAPI component name (`Foo_for_Bar_and_Baz`) to the Rust
+/// identifier progenitor emits (`FooForBarAndBaz`).
+fn strip_underscores(s: &str) -> String {
+    let mut out = String::with_capacity(s.len());
+    let mut upper_next = false;
+    for ch in s.chars() {
+        if ch == '_' {
+            upper_next = true;
+        } else if upper_next {
+            out.extend(ch.to_uppercase());
+            upper_next = false;
+        } else {
+            out.push(ch);
+        }
+    }
+    out
+}

rfd-cli/build.rs

@@ -0,0 +1,49 @@
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v. 2.0. If a copy of the MPL was not distributed with this
+// file, You can obtain one at https://mozilla.org/MPL/2.0/.
+
+// Verifies that every JSON response type the API can produce has a matching
+// arm in the dispatch table in `src/main.rs`.
+//
+// The expected set of schema names is generated at build time by `build.rs`,
+// which reads `rfd-api-spec.json` and emits Rust source that references real
+// types from `rfd_sdk::types`. The compiler verifies each referenced type
+// still exists, so SDK rename/removal breaks the build instead of silently
+// passing the test.
+
+use regex::Regex;
+use std::collections::HashSet;
+use std::fs;
+use std::path::PathBuf;
+
+include!(concat!(env!("OUT_DIR"), "/expected_response_types.rs"));
+
+#[test]
+fn dispatch_table_covers_all_api_response_types() {
+    let expected: HashSet<String> = expected_response_schema_names().into_iter().collect();
+
+    let main_src =
+        fs::read_to_string(PathBuf::from(env!("CARGO_MANIFEST_DIR")).join("src/main.rs"))
+            .expect("read rfd-cli/src/main.rs");
+
+    // Names handled by the dispatch table in main.rs: any string literal
+    // followed by `=>`. Over-collects on purpose (catches non-dispatch arms
+    // too) — we only assert `expected ⊆ handled`.
+    let arm_re = Regex::new(r#""([A-Za-z_][A-Za-z_0-9<>]*)"\s*=>"#).unwrap();
+    let handled: HashSet<String> = arm_re
+        .captures_iter(&main_src)
+        .map(|c| c[1].to_string())
+        .collect();
+
+    let mut missing: Vec<&String> = expected.difference(&handled).collect();
+    missing.sort();
+    assert!(
+        missing.is_empty(),
+        "API responses with no dispatch arm in rfd-cli/src/main.rs:\n  - {}",
+        missing
+            .iter()
+            .map(|s| s.as_str())
+            .collect::<Vec<_>>()
+            .join("\n  - ")
+    );
+}