Optional request bodies

The idea is to identify args for the CLI that can be omitted since the
entire body is technically optional.

Author: svix-onelson

src/api.rs

@@ -28,7 +28,11 @@ pub(crate) struct Api {
 }
 
 impl Api {
-    pub(crate) fn new(paths: openapi::Paths, with_deprecated: bool) -> anyhow::Result<Self> {
+    pub(crate) fn new(
+        paths: openapi::Paths,
+        with_deprecated: bool,
+        component_schemas: IndexMap<String, aide::openapi::SchemaObject>,
+    ) -> anyhow::Result<Self> {
         let mut resources = BTreeMap::new();
 
         for (path, pi) in paths {
@@ -46,7 +50,9 @@ impl Api {
                     continue;
                 }
 
-                if let Some((res_path, op)) = Operation::from_openapi(&path, method, op) {
+                if let Some((res_path, op)) =
+                    Operation::from_openapi(&path, method, op, &component_schemas)
+                {
                     let resource = get_or_insert_resource(&mut resources, res_path);
                     if op.method == "post" {
                         resource.has_post_operation = true;
@@ -223,6 +229,10 @@ struct Operation {
     /// Name of the request body type, if any.
     #[serde(skip_serializing_if = "Option::is_none")]
     request_body_schema_name: Option<String>,
+    /// Some request bodies are required, but all the fields are optional (i.e. the CLI can omit
+    /// this from the argument list).
+    /// Only useful when `request_body_schema_name` is `Some`.
+    request_body_all_optional: bool,
     /// Name of the response body type, if any.
     #[serde(skip_serializing_if = "Option::is_none")]
     response_body_schema_name: Option<String>,
@@ -234,6 +244,7 @@ impl Operation {
         path: &str,
         method: &str,
         op: openapi::Operation,
+        component_schemas: &IndexMap<String, aide::openapi::SchemaObject>,
     ) -> Option<(Vec<String>, Self)> {
         let Some(op_id) = op.operation_id else {
             // ignore operations without an operationId
@@ -343,7 +354,7 @@ impl Operation {
             }
         }
 
-        let request_body_schema_name = op.request_body.and_then(|b| match b {
+        let request_body_schema_name = op.request_body.clone().and_then(|b| match b {
             ReferenceOr::Item(mut req_body) => {
                 assert!(req_body.required);
                 assert!(req_body.extensions.is_empty());
@@ -372,6 +383,53 @@ impl Operation {
             }
         });
 
+        let request_body_all_optional = op
+            .request_body
+            .map(|r| {
+                match r {
+                    ReferenceOr::Reference { .. } => {
+                        todo!("reference")
+                    }
+                    ReferenceOr::Item(body) => {
+                        if let Some(mt) = body.content.get("application/json") {
+                            match mt.schema.as_ref().map(|so| &so.json_schema) {
+                                Some(Schema::Object(schemars::schema::SchemaObject {
+                                    object: Some(ov),
+                                    ..
+                                })) => {
+                                    dbg!((&op_id, ov.required.is_empty()));
+                                    return ov.required.is_empty();
+                                }
+                                Some(Schema::Object(schemars::schema::SchemaObject {
+                                    reference: Some(s),
+                                    ..
+                                })) => {
+                                    match component_schemas
+                                        .get(
+                                            &get_schema_name(Some(s.clone()))
+                                                .expect("schema should exist"),
+                                        )
+                                        .map(|so| &so.json_schema)
+                                    {
+                                        Some(Schema::Object(schemars::schema::SchemaObject {
+                                            object: Some(ov),
+                                            ..
+                                        })) => {
+                                            dbg!((&op_id, ov.required.is_empty()));
+                                            return ov.required.is_empty();
+                                        }
+                                        _ => todo!("just give up at the double ref"),
+                                    }
+                                }
+                                _ => {}
+                            }
+                        }
+                    }
+                }
+                false
+            })
+            .unwrap_or_default();
+
         let response_body_schema_name = op.responses.and_then(|r| {
             assert_eq!(r.default, None);
             assert!(r.extensions.is_empty());
@@ -415,6 +473,7 @@ impl Operation {
             header_params,
             query_params,
             request_body_schema_name,
+            request_body_all_optional,
             response_body_schema_name,
         };
         Some((res_path, op))

src/main.rs

@@ -57,10 +57,12 @@ fn main() -> anyhow::Result<()> {
 
     let output_dir = TempDir::new().context("failed to create tempdir")?;
 
+    let component_schemas = spec.components.clone().unwrap_or_default().schemas;
+
     let mut components = spec.components.unwrap_or_default();
 
     if let Some(paths) = spec.paths {
-        let api = Api::new(paths, with_deprecated).unwrap();
+        let api = Api::new(paths, with_deprecated, component_schemas).unwrap();
         {
             let mut api_file = BufWriter::new(File::create("api.ron")?);
             writeln!(api_file, "{api:#?}")?;

templates/svix_cli_resource.rs.jinja

@@ -86,7 +86,12 @@ pub enum {{ resource_type_name }}Commands {
             {# body parameter struct -#}
             {% if op.request_body_schema_name is defined -%}
                 {{ op.request_body_schema_name | to_snake_case }}:
-                    JsonOf<{{ op.request_body_schema_name }}>,
+                {% if op.request_body_all_optional %}
+                Option<JsonOf<{{ op.request_body_schema_name }}>>
+                {% else %}
+                JsonOf<{{ op.request_body_schema_name }}>
+                {% endif %}
+                ,
             {% endif -%}
 
             {# query parameters -#}