Special-ify some HTTP types

Rather than having HTTP types participate specialy in the case-conversion infra,
this commit (authored by Codex, with message by me) makes them into "special" types
with double-underscore variant and field names,
and with special recognition by codegen and schema validation.

Author: gefjon

crates/codegen/src/cpp.rs

@@ -90,6 +90,9 @@ impl<'opts> Cpp<'opts> {
             AlgebraicTypeUse::TimeDuration => write!(output, "__sdk::TimeDuration"),
             AlgebraicTypeUse::ScheduleAt => write!(output, "__sdk::ScheduleAt"),
             AlgebraicTypeUse::Uuid => write!(output, "__sdk::Uuid"),
+            AlgebraicTypeUse::HttpRequestAndBody | AlgebraicTypeUse::HttpResponseAndBody => {
+                unimplemented!("Http request/response types are not supported in C++ output")
+            }
             AlgebraicTypeUse::Unit => write!(output, "std::monostate"),
             AlgebraicTypeUse::Never => write!(output, "std::monostate"),
             AlgebraicTypeUse::Ref(type_ref) => {

crates/codegen/src/csharp.rs

@@ -1231,6 +1231,9 @@ fn ty_fmt<'a>(module: &'a ModuleDef, ty: &'a AlgebraicTypeUse) -> impl fmt::Disp
             PrimitiveType::F32 => "float",
             PrimitiveType::F64 => "double",
         }),
+        AlgebraicTypeUse::HttpRequestAndBody | AlgebraicTypeUse::HttpResponseAndBody => {
+            unimplemented!("Http request/response types are not supported in C# output")
+        }
         AlgebraicTypeUse::Never => unimplemented!(),
     })
 }
@@ -1276,6 +1279,9 @@ fn ty_fmt_with_ns<'a>(module: &'a ModuleDef, ty: &'a AlgebraicTypeUse, namespace
             PrimitiveType::F32 => "float",
             PrimitiveType::F64 => "double",
         }),
+        AlgebraicTypeUse::HttpRequestAndBody | AlgebraicTypeUse::HttpResponseAndBody => {
+            unimplemented!("Http request/response types are not supported in C# output")
+        }
         AlgebraicTypeUse::Never => unimplemented!(),
     })
 }
@@ -1307,6 +1313,9 @@ fn default_init(ctx: &TypespaceForGenerate, ty: &AlgebraicTypeUse) -> Option<&'s
         | AlgebraicTypeUse::Timestamp
         | AlgebraicTypeUse::TimeDuration
         | AlgebraicTypeUse::Uuid => None,
+        AlgebraicTypeUse::HttpRequestAndBody | AlgebraicTypeUse::HttpResponseAndBody => {
+            unimplemented!("Http request/response types are not supported in C# output")
+        }
         AlgebraicTypeUse::Never => unimplemented!("never types are not yet supported in C# output"),
     }
 }

crates/codegen/src/rust.rs

@@ -826,6 +826,8 @@ pub fn write_type<W: Write>(module: &ModuleDef, out: &mut W, ty: &AlgebraicTypeU
         AlgebraicTypeUse::Timestamp => write!(out, "__sdk::Timestamp")?,
         AlgebraicTypeUse::TimeDuration => write!(out, "__sdk::TimeDuration")?,
         AlgebraicTypeUse::Uuid => write!(out, "__sdk::Uuid")?,
+        AlgebraicTypeUse::HttpRequestAndBody => write!(out, "__sdk::HttpRequestAndBody")?,
+        AlgebraicTypeUse::HttpResponseAndBody => write!(out, "__sdk::HttpResponseAndBody")?,
         AlgebraicTypeUse::ScheduleAt => write!(out, "__sdk::ScheduleAt")?,
         AlgebraicTypeUse::Option(inner_ty) => {
             write!(out, "Option::<")?;

crates/codegen/src/typescript.rs

@@ -789,6 +789,7 @@ fn write_type_builder<W: Write>(module: &ModuleDef, out: &mut W, ty: &AlgebraicT
         AlgebraicTypeUse::TimeDuration => write!(out, "__t.timeDuration()")?,
         AlgebraicTypeUse::ScheduleAt => write!(out, "__t.scheduleAt()")?,
         AlgebraicTypeUse::Uuid => write!(out, "__t.uuid()")?,
+        AlgebraicTypeUse::HttpRequestAndBody | AlgebraicTypeUse::HttpResponseAndBody => unimplemented!(),
         AlgebraicTypeUse::Option(inner_ty) => {
             write!(out, "__t.option(")?;
             write_type_builder(module, out, inner_ty)?;
@@ -916,6 +917,7 @@ fn needs_parens_within_array(ty: &AlgebraicTypeUse) -> bool {
         AlgebraicTypeUse::ScheduleAt | AlgebraicTypeUse::Option(_) | AlgebraicTypeUse::Result { .. } => {
             true
         }
+        AlgebraicTypeUse::HttpRequestAndBody | AlgebraicTypeUse::HttpResponseAndBody => unimplemented!(),
     }
 }
 
@@ -934,6 +936,7 @@ pub fn write_type<W: Write>(
         AlgebraicTypeUse::Timestamp => write!(out, "__Infer<typeof __t.timestamp()>")?,
         AlgebraicTypeUse::TimeDuration => write!(out, "__Infer<typeof __t.timeDuration()>")?,
         AlgebraicTypeUse::Uuid => write!(out, "__Uuid")?,
+        AlgebraicTypeUse::HttpRequestAndBody | AlgebraicTypeUse::HttpResponseAndBody => unimplemented!(),
         AlgebraicTypeUse::ScheduleAt => write!(
             out,
             "{{ tag: \"Interval\", value: __Infer<typeof __t.timeDuration()> }} | {{ tag: \"Time\", value: __Infer<typeof __t.timestamp()> }}"

crates/codegen/src/unrealcpp.rs

@@ -4163,6 +4163,9 @@ fn get_array_element_type_name(module: &ModuleDef, elem: &AlgebraicTypeUse) -> S
         AlgebraicTypeUse::Timestamp => "Timestamp".to_string(),
         AlgebraicTypeUse::TimeDuration => "TimeDuration".to_string(),
         AlgebraicTypeUse::Uuid => "Uuid".to_string(),
+        AlgebraicTypeUse::HttpRequestAndBody | AlgebraicTypeUse::HttpResponseAndBody => {
+            unimplemented!("Http request/response types are not supported in Unreal output")
+        }
         AlgebraicTypeUse::ScheduleAt => "ScheduleAt".to_string(),
         AlgebraicTypeUse::Ref(r) => type_ref_name(module, *r),
         AlgebraicTypeUse::Option(nested_inner) => {
@@ -4203,6 +4206,9 @@ fn get_optional_type_name(module: &ModuleDef, inner: &AlgebraicTypeUse) -> Strin
         AlgebraicTypeUse::Timestamp => "OptionalTimestamp".to_string(),
         AlgebraicTypeUse::TimeDuration => "OptionalTimeDuration".to_string(),
         AlgebraicTypeUse::Uuid => "OptionalUuid".to_string(),
+        AlgebraicTypeUse::HttpRequestAndBody | AlgebraicTypeUse::HttpResponseAndBody => {
+            unimplemented!("Http request/response types are not supported in Unreal output")
+        }
         AlgebraicTypeUse::ScheduleAt => "OptionalScheduleAt".to_string(),
         AlgebraicTypeUse::Array(elem) => {
             // Generate specific optional array types based on element type
@@ -4523,6 +4529,9 @@ fn get_type_name_for_result(module: &ModuleDef, ty: &AlgebraicTypeUse) -> String
         AlgebraicTypeUse::TimeDuration => "TimeDuration".to_string(),
         AlgebraicTypeUse::ScheduleAt => "ScheduleAt".to_string(),
         AlgebraicTypeUse::Uuid => "Uuid".to_string(),
+        AlgebraicTypeUse::HttpRequestAndBody | AlgebraicTypeUse::HttpResponseAndBody => {
+            unimplemented!("Http request/response types are not supported in Unreal output")
+        }
         AlgebraicTypeUse::Unit => "Unit".to_string(),
         AlgebraicTypeUse::Array(elem) => {
             // Generate specific array types based on element type
@@ -4918,6 +4927,9 @@ fn should_pass_by_value_in_delegate(_module: &ModuleDef, ty: &AlgebraicTypeUse)
         AlgebraicTypeUse::Timestamp => false,    // FSpacetimeDBTimestamp is a USTRUCT
         AlgebraicTypeUse::TimeDuration => false, // FSpacetimeDBTimeDuration is a USTRUCT
         AlgebraicTypeUse::Uuid => false,         // FSpacetimeDBUuid is a USTRUCT
+        AlgebraicTypeUse::HttpRequestAndBody | AlgebraicTypeUse::HttpResponseAndBody => {
+            unimplemented!("Http request/response types are not supported in Unreal output")
+        }
         // Custom structs/enums use const references
         AlgebraicTypeUse::Ref(_) => false,
         AlgebraicTypeUse::Array(_) => false, // Arrays use const references
@@ -4961,6 +4973,9 @@ fn is_blueprintable(module: &ModuleDef, ty: &AlgebraicTypeUse) -> bool {
         AlgebraicTypeUse::Timestamp => true,
         AlgebraicTypeUse::TimeDuration => true,
         AlgebraicTypeUse::Uuid => true,
+        AlgebraicTypeUse::HttpRequestAndBody | AlgebraicTypeUse::HttpResponseAndBody => {
+            unimplemented!("Http request/response types are not supported in Unreal output")
+        }
         AlgebraicTypeUse::ScheduleAt => true, // ScheduleAt is blueprintable as a property (TObjectPtr)
         AlgebraicTypeUse::Unit => true,
         AlgebraicTypeUse::Ref(r) => {
@@ -5000,6 +5015,9 @@ fn is_type_blueprintable_for_delegates(module: &ModuleDef, ty: &AlgebraicTypeUse
         AlgebraicTypeUse::Timestamp => true,
         AlgebraicTypeUse::TimeDuration => true,
         AlgebraicTypeUse::Uuid => true,
+        AlgebraicTypeUse::HttpRequestAndBody | AlgebraicTypeUse::HttpResponseAndBody => {
+            unimplemented!("Http request/response types are not supported in Unreal output")
+        }
         AlgebraicTypeUse::ScheduleAt => true,
         AlgebraicTypeUse::Unit => true,
         AlgebraicTypeUse::Ref(r) => {
@@ -5428,6 +5446,9 @@ fn cpp_ty_fmt_impl<'a>(
         AlgebraicTypeUse::Timestamp => f.write_str("FSpacetimeDBTimestamp"),
         AlgebraicTypeUse::TimeDuration => f.write_str("FSpacetimeDBTimeDuration"),
         AlgebraicTypeUse::Uuid => f.write_str("FSpacetimeDBUuid"),
+        AlgebraicTypeUse::HttpRequestAndBody | AlgebraicTypeUse::HttpResponseAndBody => {
+            unimplemented!("Http request/response types are not supported in Unreal output")
+        }
         AlgebraicTypeUse::ScheduleAt => f.write_str("FSpacetimeDBScheduleAt"),
         AlgebraicTypeUse::Unit => f.write_str("FSpacetimeDBUnit"),
 
@@ -5497,6 +5518,9 @@ fn cpp_ty_init_fmt_impl(module: &ModuleDef, ty: &AlgebraicTypeUse) -> String {
         AlgebraicTypeUse::TimeDuration => String::new(),
         AlgebraicTypeUse::ScheduleAt => String::new(),
         AlgebraicTypeUse::Uuid => String::new(),
+        AlgebraicTypeUse::HttpRequestAndBody | AlgebraicTypeUse::HttpResponseAndBody => {
+            unimplemented!("Http request/response types are not supported in Unreal output")
+        }
         AlgebraicTypeUse::Unit => String::new(),
         // --------- references to user-defined types ---------
         AlgebraicTypeUse::Ref(r) => {
@@ -5560,6 +5584,9 @@ fn collect_includes_for_type(module: &ModuleDef, ty: &AlgebraicTypeUse, out: &mu
         Identity | ConnectionId | Timestamp | TimeDuration | ScheduleAt | Uuid => {
             out.insert("Types/Builtins.h".to_string());
         }
+        HttpRequestAndBody | HttpResponseAndBody => {
+            unimplemented!("Http request/response types are not supported in Unreal output")
+        }
         // Large integer primitives also need Builtins.h (for LargeIntegers.h)
         Primitive(PrimitiveType::I128)
         | Primitive(PrimitiveType::U128)

crates/lib/src/db/raw_def/v10.rs

@@ -135,18 +135,6 @@ pub struct NameMapping {
     pub canonical_name: RawIdentifier,
 }
 
-#[derive(Debug, Clone, SpacetimeType)]
-#[sats(crate = crate)]
-#[cfg_attr(feature = "test", derive(PartialEq, Eq, Ord, PartialOrd))]
-pub struct EnumVariantNameMapping {
-    /// The source name of the containing enum.
-    pub enum_source_name: RawIdentifier,
-    /// The source name of the variant.
-    pub variant_source_name: RawIdentifier,
-    /// The canonical name of the variant.
-    pub variant_canonical_name: RawIdentifier,
-}
-
 #[derive(Debug, Clone, SpacetimeType)]
 #[sats(crate = crate)]
 #[cfg_attr(feature = "test", derive(PartialEq, Eq, Ord, PartialOrd))]
@@ -155,7 +143,6 @@ pub enum ExplicitNameEntry {
     Table(NameMapping),
     Function(NameMapping),
     Index(NameMapping),
-    EnumVariant(EnumVariantNameMapping),
 }
 
 #[derive(Debug, Default, Clone, SpacetimeType)]
@@ -196,19 +183,6 @@ impl ExplicitNames {
         }));
     }
 
-    pub fn insert_enum_variant(
-        &mut self,
-        enum_source_name: impl Into<RawIdentifier>,
-        variant_source_name: impl Into<RawIdentifier>,
-        variant_canonical_name: impl Into<RawIdentifier>,
-    ) {
-        self.insert(ExplicitNameEntry::EnumVariant(EnumVariantNameMapping {
-            enum_source_name: enum_source_name.into(),
-            variant_source_name: variant_source_name.into(),
-            variant_canonical_name: variant_canonical_name.into(),
-        }));
-    }
-
     pub fn merge(&mut self, other: ExplicitNames) {
         self.entries.extend(other.entries);
     }
@@ -1193,18 +1167,16 @@ impl TypespaceBuilder for RawModuleDefV10Builder {
         if let btree_map::Entry::Occupied(o) = self.type_map.entry(typeid) {
             AlgebraicType::Ref(*o.get())
         } else {
-            let (slot_ref, enum_source_name) = {
+            let slot_ref = {
                 let ts = self.typespace_mut();
                 // Bind a fresh alias to the unit type.
                 let slot_ref = ts.add(AlgebraicType::unit());
                 // Relate `typeid -> fresh alias`.
                 self.type_map.insert(typeid, slot_ref);
 
                 // Alias provided? Relate `name -> slot_ref`.
-                let enum_source_name = if let Some(sats_name) = source_name {
+                if let Some(sats_name) = source_name {
                     let source_name = sats_name_to_scoped_name_v10(sats_name);
-                    let enum_source_name =
-                        should_register_enum_variant_names(sats_name).then(|| source_name.source_name.clone());
 
                     self.types_mut().push(RawTypeDefV10 {
                         source_name,
@@ -1215,44 +1187,18 @@ impl TypespaceBuilder for RawModuleDefV10Builder {
                         // macro doesn't know about the default ordering yet.
                         custom_ordering: true,
                     });
-                    enum_source_name
-                } else {
-                    None
-                };
-                (slot_ref, enum_source_name)
+                }
+                slot_ref
             };
 
             // Borrow of `v` has ended here, so we can now convince the borrow checker.
             let ty = make_ty(self);
             self.typespace_mut()[slot_ref] = ty;
-            let enum_variants = match (&enum_source_name, &self.typespace_mut()[slot_ref]) {
-                (Some(enum_source_name), AlgebraicType::Sum(sum)) => Some((
-                    enum_source_name.clone(),
-                    sum.variants
-                        .iter()
-                        .filter_map(|variant| variant.name().cloned())
-                        .collect::<Vec<_>>(),
-                )),
-                _ => None,
-            };
-            if let Some((enum_source_name, variant_names)) = enum_variants {
-                for variant_name in variant_names {
-                    self.explicit_names_mut().insert_enum_variant(
-                        enum_source_name.clone(),
-                        variant_name.clone(),
-                        variant_name,
-                    );
-                }
-            }
             AlgebraicType::Ref(slot_ref)
         }
     }
 }
 
-fn should_register_enum_variant_names(sats_name: &str) -> bool {
-    matches!(sats_name, "HttpMethod" | "HttpVersion")
-}
-
 pub fn reducer_default_ok_return_type() -> AlgebraicType {
     AlgebraicType::unit()
 }

crates/lib/src/http.rs

@@ -18,7 +18,13 @@
 //! Instead, if/when we want to add new functionality which requires sending additional information,
 //! we'll define a new versioned ABI call which uses new types for interchange.
 
-use spacetimedb_sats::{time_duration::TimeDuration, SpacetimeType};
+use crate::de::Deserialize;
+use crate::ser::Serialize;
+use spacetimedb_sats::{
+    product_type::{HTTP_BODY_TAG, HTTP_REQUEST_TAG, HTTP_RESPONSE_TAG},
+    time_duration::TimeDuration,
+    AlgebraicType, SpacetimeType,
+};
 
 /// Represents an HTTP request which can be made from a procedure running in a SpacetimeDB database.
 #[derive(Clone, SpacetimeType)]
@@ -170,20 +176,36 @@ impl Response {
 ///
 /// This is used for incoming HTTP route handling where the body bytes are kept separate
 /// from the metadata-only [`Request`].
-#[derive(Clone, SpacetimeType)]
-#[sats(crate = crate, name = "HttpRequestAndBody")]
+#[derive(Clone, Serialize, Deserialize)]
 pub struct RequestAndBody {
     pub request: Request,
     pub body: Box<[u8]>,
 }
 
+impl SpacetimeType for RequestAndBody {
+    fn make_type<S: spacetimedb_sats::typespace::TypespaceBuilder>(typespace: &mut S) -> AlgebraicType {
+        AlgebraicType::product([
+            (HTTP_REQUEST_TAG, Request::make_type(typespace)),
+            (HTTP_BODY_TAG, AlgebraicType::array(AlgebraicType::U8)),
+        ])
+    }
+}
+
 /// A response paired with its body bytes.
 ///
 /// This is used for HTTP route handling where the body bytes are kept separate
 /// from the metadata-only [`Response`].
-#[derive(Clone, SpacetimeType)]
-#[sats(crate = crate, name = "HttpResponseAndBody")]
+#[derive(Clone, Serialize, Deserialize)]
 pub struct ResponseAndBody {
     pub response: Response,
     pub body: Box<[u8]>,
 }
+
+impl SpacetimeType for ResponseAndBody {
+    fn make_type<S: spacetimedb_sats::typespace::TypespaceBuilder>(typespace: &mut S) -> AlgebraicType {
+        AlgebraicType::product([
+            (HTTP_RESPONSE_TAG, Response::make_type(typespace)),
+            (HTTP_BODY_TAG, AlgebraicType::array(AlgebraicType::U8)),
+        ])
+    }
+}