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

@@ -223,6 +223,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>,
@@ -343,7 +347,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 +376,38 @@ 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),
+                                    ..
+                                })) => {
+                                    todo!("lookup {s}");
+                                }
+                                _ => {}
+                            }
+                        }
+                    }
+                }
+                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 +451,7 @@ impl Operation {
             header_params,
             query_params,
             request_body_schema_name,
+            request_body_all_optional,
             response_body_schema_name,
         };
         Some((res_path, op))

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 -#}