feat(components): Add enum to component metadata for distinguishing the root app from child components (#26097)

This moves to an enum so we don't have synthesize `name` and `args` for the app. We can let these two variants diverge more over time.

One interesting bit is that I left the `path: ComponentDefinitionPath` field alone, which means that the root app has definition path `""`, which makes sense as a relative path from `"convex/"`.

GitOrigin-RevId: b4d085cc7b4fd576557bb710298ae08b3e538b7c

Author: Sujay Jayakar

crates/application/src/tests/components.rs

@@ -6,10 +6,12 @@ use common::{
             ComponentArgument,
             ComponentArgumentValidator,
             ComponentDefinitionMetadata,
+            ComponentDefinitionType,
             ComponentExport,
             ComponentInstantiation,
         },
         ComponentMetadata,
+        ComponentType,
     },
     components::{
         ComponentFunctionPath,
@@ -138,8 +140,7 @@ bar.invokeAction = async (requestId, argsStr) => {
     let root_component_id = {
         let definition = ComponentDefinitionMetadata {
             path: "".parse()?,
-            name: "app".parse()?,
-            args: btreemap! {},
+            definition_type: ComponentDefinitionType::App,
             child_components: vec![ComponentInstantiation {
                 name: "chatWaitlist".parse()?,
                 path: "../node_modules/waitlist".parse()?,
@@ -159,8 +160,7 @@ bar.invokeAction = async (requestId, argsStr) => {
 
         let component = ComponentMetadata {
             definition_id: definition_id.internal_id(),
-            parent_and_name: None,
-            args: btreemap! {},
+            component_type: ComponentType::App,
         };
         let component_id = SystemMetadataModel::new_global(&mut tx)
             .insert(&COMPONENTS_TABLE, component.try_into()?)
@@ -171,9 +171,11 @@ bar.invokeAction = async (requestId, argsStr) => {
     {
         let definition = ComponentDefinitionMetadata {
             path: "../node_modules/waitlist".parse()?,
-            name: "waitlist".parse()?,
-            args: btreemap! {
-                "maxLength".parse()? => ComponentArgumentValidator::Value(Validator::Float64),
+            definition_type: ComponentDefinitionType::ChildComponent {
+                name: "waitlist".parse()?,
+                args: btreemap! {
+                    "maxLength".parse()? => ComponentArgumentValidator::Value(Validator::Float64),
+                },
             },
             child_components: vec![],
             exports: btreemap! {
@@ -188,9 +190,12 @@ bar.invokeAction = async (requestId, argsStr) => {
 
         let component = ComponentMetadata {
             definition_id: definition_id.internal_id(),
-            parent_and_name: Some((root_component_id, "chatWaitlist".parse()?)),
-            args: btreemap! {
-                "maxLength".parse()? => Resource::Value(ConvexValue::Float64(10.)),
+            component_type: ComponentType::ChildComponent {
+                parent: root_component_id,
+                name: "chatWaitlist".parse()?,
+                args: btreemap! {
+                    "maxLength".parse()? => Resource::Value(ConvexValue::Float64(10.)),
+                },
             },
         };
         SystemMetadataModel::new_global(&mut tx)

crates/common/src/bootstrap_model/components/definition.rs

@@ -24,12 +24,21 @@ use crate::{
 #[cfg_attr(any(test, feature = "testing"), derive(proptest_derive::Arbitrary))]
 pub struct ComponentDefinitionMetadata {
     pub path: ComponentDefinitionPath,
-    pub name: ComponentName,
-    pub args: BTreeMap<Identifier, ComponentArgumentValidator>,
+    pub definition_type: ComponentDefinitionType,
     pub child_components: Vec<ComponentInstantiation>,
     pub exports: BTreeMap<Identifier, ComponentExport>,
 }
 
+#[derive(Debug, Clone, Eq, PartialEq)]
+#[cfg_attr(any(test, feature = "testing"), derive(proptest_derive::Arbitrary))]
+pub enum ComponentDefinitionType {
+    App,
+    ChildComponent {
+        name: ComponentName,
+        args: BTreeMap<Identifier, ComponentArgumentValidator>,
+    },
+}
+
 #[derive(Debug, Clone, Eq, PartialEq)]
 pub struct ComponentInstantiation {
     pub name: ComponentName,
@@ -56,14 +65,24 @@ pub enum ComponentArgument {
 }
 
 #[derive(Debug, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
 struct SerializedComponentDefinitionMetadata {
     path: String,
-    name: String,
-    inputs: Vec<(String, SerializedComponentArgumentValidator)>,
+    definition_type: SerializedComponentDefinitionType,
     child_components: Vec<SerializedComponentInstantiation>,
     exports: SerializedComponentExport,
 }
 
+#[derive(Debug, Serialize, Deserialize)]
+#[serde(tag = "type", rename_all = "camelCase")]
+enum SerializedComponentDefinitionType {
+    App {},
+    ChildComponent {
+        name: String,
+        args: Vec<(String, SerializedComponentArgumentValidator)>,
+    },
+}
+
 #[derive(Debug, Serialize, Deserialize)]
 #[serde(tag = "type", rename_all = "camelCase")]
 enum SerializedComponentArgumentValidator {
@@ -101,12 +120,7 @@ impl TryFrom<ComponentDefinitionMetadata> for SerializedComponentDefinitionMetad
     fn try_from(m: ComponentDefinitionMetadata) -> anyhow::Result<Self> {
         Ok(Self {
             path: String::from(m.path),
-            name: String::from(m.name),
-            inputs: m
-                .args
-                .into_iter()
-                .map(|(k, v)| anyhow::Ok((String::from(k), v.try_into()?)))
-                .try_collect()?,
+            definition_type: m.definition_type.try_into()?,
             child_components: m
                 .child_components
                 .into_iter()
@@ -126,12 +140,7 @@ impl TryFrom<SerializedComponentDefinitionMetadata> for ComponentDefinitionMetad
         };
         Ok(Self {
             path: m.path.parse()?,
-            name: m.name.parse()?,
-            args: m
-                .inputs
-                .into_iter()
-                .map(|(k, v)| anyhow::Ok((k.parse()?, v.try_into()?)))
-                .try_collect()?,
+            definition_type: m.definition_type.try_into()?,
             child_components: m
                 .child_components
                 .into_iter()
@@ -142,6 +151,42 @@ impl TryFrom<SerializedComponentDefinitionMetadata> for ComponentDefinitionMetad
     }
 }
 
+impl TryFrom<ComponentDefinitionType> for SerializedComponentDefinitionType {
+    type Error = anyhow::Error;
+
+    fn try_from(t: ComponentDefinitionType) -> anyhow::Result<Self> {
+        Ok(match t {
+            ComponentDefinitionType::App => Self::App {},
+            ComponentDefinitionType::ChildComponent { name, args } => Self::ChildComponent {
+                name: name.to_string(),
+                args: args
+                    .into_iter()
+                    .map(|(k, v)| anyhow::Ok((String::from(k), v.try_into()?)))
+                    .try_collect()?,
+            },
+        })
+    }
+}
+
+impl TryFrom<SerializedComponentDefinitionType> for ComponentDefinitionType {
+    type Error = anyhow::Error;
+
+    fn try_from(t: SerializedComponentDefinitionType) -> anyhow::Result<Self> {
+        Ok(match t {
+            SerializedComponentDefinitionType::App {} => Self::App,
+            SerializedComponentDefinitionType::ChildComponent { name, args } => {
+                Self::ChildComponent {
+                    name: name.parse()?,
+                    args: args
+                        .into_iter()
+                        .map(|(k, v)| anyhow::Ok((k.parse()?, v.try_into()?)))
+                        .try_collect()?,
+                }
+            },
+        })
+    }
+}
+
 impl TryFrom<ComponentInstantiation> for SerializedComponentInstantiation {
     type Error = anyhow::Error;
 

crates/common/src/bootstrap_model/components/mod.rs

@@ -22,35 +22,50 @@ use crate::components::{
 #[cfg_attr(any(test, feature = "testing"), derive(proptest_derive::Arbitrary))]
 pub struct ComponentMetadata {
     pub definition_id: InternalId,
-    pub parent_and_name: Option<(InternalId, ComponentName)>,
-    pub args: BTreeMap<Identifier, Resource>,
+    pub component_type: ComponentType,
+}
+
+#[derive(Debug, Clone, Eq, PartialEq)]
+#[cfg_attr(any(test, feature = "testing"), derive(proptest_derive::Arbitrary))]
+pub enum ComponentType {
+    App,
+    ChildComponent {
+        parent: InternalId,
+        name: ComponentName,
+        args: BTreeMap<Identifier, Resource>,
+    },
 }
 
 #[derive(Debug, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
 struct SerializedComponentMetadata {
     pub definition_id: String,
     pub parent: Option<String>,
     pub name: Option<String>,
-    pub args: Vec<(String, SerializedResource)>,
+    pub args: Option<Vec<(String, SerializedResource)>>,
 }
 
 impl TryFrom<ComponentMetadata> for SerializedComponentMetadata {
     type Error = anyhow::Error;
 
     fn try_from(m: ComponentMetadata) -> anyhow::Result<Self> {
-        let (parent, name) = match m.parent_and_name {
-            Some((parent, name)) => (Some(parent.to_string()), Some(name.to_string())),
-            None => (None, None),
+        let (parent, name, args) = match m.component_type {
+            ComponentType::App => (None, None, None),
+            ComponentType::ChildComponent { parent, name, args } => (
+                Some(parent.to_string()),
+                Some(name.to_string()),
+                Some(
+                    args.into_iter()
+                        .map(|(k, v)| anyhow::Ok((k.to_string(), v.try_into()?)))
+                        .try_collect()?,
+                ),
+            ),
         };
         Ok(Self {
             definition_id: m.definition_id.to_string(),
             parent,
             name,
-            args: m
-                .args
-                .into_iter()
-                .map(|(k, v)| anyhow::Ok((String::from(k), v.try_into()?)))
-                .try_collect()?,
+            args,
         })
     }
 }
@@ -59,18 +74,21 @@ impl TryFrom<SerializedComponentMetadata> for ComponentMetadata {
     type Error = anyhow::Error;
 
     fn try_from(m: SerializedComponentMetadata) -> anyhow::Result<Self> {
+        let component_type = match (m.parent, m.name, m.args) {
+            (None, None, None) => ComponentType::App,
+            (Some(parent), Some(name), Some(args)) => ComponentType::ChildComponent {
+                parent: parent.parse()?,
+                name: name.parse()?,
+                args: args
+                    .into_iter()
+                    .map(|(k, v)| Ok((k.parse()?, v.try_into()?)))
+                    .collect::<anyhow::Result<_>>()?,
+            },
+            _ => anyhow::bail!("Invalid component type"),
+        };
         Ok(Self {
             definition_id: m.definition_id.parse()?,
-            parent_and_name: match (m.parent, m.name) {
-                (Some(parent), Some(name)) => Some((parent.parse()?, name.parse()?)),
-                (None, None) => None,
-                _ => anyhow::bail!("expected both parent and name or neither"),
-            },
-            args: m
-                .args
-                .into_iter()
-                .map(|(k, v)| anyhow::Ok((k.parse()?, v.try_into()?)))
-                .try_collect()?,
+            component_type,
         })
     }
 }

crates/database/src/bootstrap_model/components/mod.rs

@@ -7,6 +7,7 @@ use common::{
     bootstrap_model::components::{
         definition::ComponentDefinitionMetadata,
         ComponentMetadata,
+        ComponentType,
     },
     components::{
         CanonicalizedComponentFunctionPath,
@@ -161,12 +162,12 @@ impl<'a, RT: Runtime> BootstrapComponentsModel<'a, RT> {
                 .await?
                 .with_context(|| format!("component {internal_id} missing"))?
                 .try_into()?;
-            component_id = match &component_doc.parent_and_name {
-                Some((parent_internal_id, name)) => {
+            component_id = match &component_doc.component_type {
+                ComponentType::App => ComponentId::Root,
+                ComponentType::ChildComponent { parent, name, .. } => {
                     path.push(name.clone());
-                    ComponentId::Child(*parent_internal_id)
+                    ComponentId::Child(*parent)
                 },
-                None => ComponentId::Root,
             };
         }
         path.reverse();
@@ -266,9 +267,11 @@ mod tests {
         bootstrap_model::components::{
             definition::{
                 ComponentDefinitionMetadata,
+                ComponentDefinitionType,
                 ComponentInstantiation,
             },
             ComponentMetadata,
+            ComponentType,
         },
         components::{
             ComponentDefinitionPath,
@@ -298,9 +301,11 @@ mod tests {
             .insert(
                 &COMPONENT_DEFINITIONS_TABLE,
                 ComponentDefinitionMetadata {
-                    name: "child".parse().unwrap(),
                     path: child_definition_path.clone(),
-                    args: BTreeMap::new(),
+                    definition_type: ComponentDefinitionType::ChildComponent {
+                        name: "child".parse().unwrap(),
+                        args: BTreeMap::new(),
+                    },
                     child_components: Vec::new(),
                     exports: BTreeMap::new(),
                 }
@@ -311,14 +316,13 @@ mod tests {
             .insert(
                 &COMPONENT_DEFINITIONS_TABLE,
                 ComponentDefinitionMetadata {
-                    name: "root".parse().unwrap(),
-                    path: "convex/app".parse().unwrap(),
+                    path: "".parse().unwrap(),
+                    definition_type: ComponentDefinitionType::App,
                     child_components: vec![ComponentInstantiation {
                         name: "child_subcomponent".parse().unwrap(),
                         path: child_definition_path,
                         args: BTreeMap::new(),
                     }],
-                    args: Default::default(),
                     exports: BTreeMap::new(),
                 }
                 .try_into()?,
@@ -329,8 +333,7 @@ mod tests {
                 &COMPONENTS_TABLE,
                 ComponentMetadata {
                     definition_id: root_definition_id.internal_id(),
-                    parent_and_name: None,
-                    args: Default::default(),
+                    component_type: ComponentType::App,
                 }
                 .try_into()?,
             )
@@ -340,8 +343,11 @@ mod tests {
                 &COMPONENTS_TABLE,
                 ComponentMetadata {
                     definition_id: child_definition_id.internal_id(),
-                    parent_and_name: Some((root_id.internal_id(), "subcomponent_child".parse()?)),
-                    args: Default::default(),
+                    component_type: ComponentType::ChildComponent {
+                        parent: root_id.internal_id(),
+                        name: "subcomponent_child".parse()?,
+                        args: Default::default(),
+                    },
                 }
                 .try_into()?,
             )