update COMPONENTS_ENABLED gating (#27529)

update components code to go through the same path regardless of whether components are enabled.

if there are is no document for root component metadata, and we're querying the root component or its definition, return the default data (ComponentType::App or an empty ComponentDefinitionMetadata). this allows us to start using components in prod without worrying about data getting out of sync. we don't need to backfill anything to get started with components.

note if there is no component metadata, you can't call function in child components, but i think that's expected.

this change is tested pretty well by existing tests, since i'm opening up the components codepaths to always run, instead of hiding them behind an env variable

GitOrigin-RevId: 0ceaf2a57ab6df701f25764cdcd4c3e1edf299b3

Author: ldanilek

crates/common/src/bootstrap_model/tables.rs

@@ -10,12 +10,9 @@ use value::{
     TableNumber,
 };
 
-use crate::{
-    components::COMPONENTS_ENABLED,
-    types::{
-        FieldName,
-        TableName,
-    },
+use crate::types::{
+    FieldName,
+    TableName,
 };
 
 pub static TABLES_TABLE: LazyLock<TableName> =
@@ -158,10 +155,6 @@ fn table_namespace_from_serialized(
 fn table_namespace_to_serialized(
     m: TableNamespace,
 ) -> anyhow::Result<Option<SerializedTableNamespace>> {
-    anyhow::ensure!(
-        *COMPONENTS_ENABLED || matches!(m, TableNamespace::Global),
-        "non-global namespaces should only be serialized when components are enabled"
-    );
     match m {
         TableNamespace::Global => Ok(None),
         TableNamespace::ByComponent(id) => Ok(Some(SerializedTableNamespace::ByComponent {

crates/common/src/components/mod.rs

@@ -35,13 +35,6 @@ pub use self::{
 pub static COMPONENTS_ENABLED: LazyLock<bool> =
     LazyLock::new(|| env_config("COMPONENTS_ENABLED", false));
 
-pub fn require_components_enabled() -> anyhow::Result<()> {
-    if !*COMPONENTS_ENABLED {
-        anyhow::bail!("Components are not enabled, set COMPONENTS_ENABLED=true to enable them.");
-    }
-    Ok(())
-}
-
 // Globally unique system-assigned ID for a component.
 #[derive(Debug, Clone, Copy, Eq, PartialEq, Ord, PartialOrd, Hash)]
 pub enum ComponentId {
@@ -72,16 +65,9 @@ impl ComponentId {
 
 impl From<ComponentId> for TableNamespace {
     fn from(value: ComponentId) -> Self {
-        if *COMPONENTS_ENABLED {
-            match value {
-                ComponentId::Root => TableNamespace::root_component(),
-                ComponentId::Child(id) => TableNamespace::ByComponent(id),
-            }
-        } else {
-            match value {
-                ComponentId::Root => TableNamespace::Global,
-                ComponentId::Child(_id) => TableNamespace::Global,
-            }
+        match value {
+            ComponentId::Root => TableNamespace::root_component(),
+            ComponentId::Child(id) => TableNamespace::ByComponent(id),
         }
     }
 }

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

@@ -8,7 +8,10 @@ use std::{
 use anyhow::Context;
 use common::{
     bootstrap_model::components::{
-        definition::ComponentDefinitionMetadata,
+        definition::{
+            ComponentDefinitionMetadata,
+            ComponentDefinitionType,
+        },
         ComponentMetadata,
         ComponentType,
     },
@@ -35,6 +38,7 @@ use common::{
     runtime::Runtime,
     types::IndexName,
 };
+use errors::ErrorMetadata;
 use value::{
     DeveloperDocumentId,
     FieldPath,
@@ -261,28 +265,67 @@ impl<'a, RT: Runtime> BootstrapComponentsModel<'a, RT> {
         Ok(result)
     }
 
+    pub async fn load_component_type(&mut self, id: ComponentId) -> anyhow::Result<ComponentType> {
+        match self.load_component(id).await? {
+            None => {
+                if id.is_root() {
+                    // The root component's metadata document may be missing if the app hasn't been
+                    // updated to use components.
+                    Ok(ComponentType::App)
+                } else {
+                    anyhow::bail!(ErrorMetadata::bad_request(
+                        "InvalidReference",
+                        format!("Component {:?} not found", id),
+                    ))
+                }
+            },
+            Some(component) => Ok(component.into_value().component_type),
+        }
+    }
+
     pub async fn load_definition(
         &mut self,
         id: ComponentDefinitionId,
-    ) -> anyhow::Result<ParsedDocument<ComponentDefinitionMetadata>> {
+    ) -> anyhow::Result<Option<ParsedDocument<ComponentDefinitionMetadata>>> {
         let internal_id = match id {
-            ComponentDefinitionId::Root => {
-                let root_component = self
-                    .root_component()
-                    .await?
-                    .context("Missing root component")?;
-                root_component.definition_id
+            ComponentDefinitionId::Root => match self.root_component().await? {
+                Some(root_component) => root_component.definition_id,
+                None => return Ok(None),
             },
             ComponentDefinitionId::Child(id) => id,
         };
         let component_definition_doc_id = self.resolve_component_definition_id(internal_id)?;
-        let doc: ParsedDocument<ComponentDefinitionMetadata> = self
-            .tx
+        self.tx
             .get(component_definition_doc_id)
             .await?
-            .context("Missing component definition")?
-            .try_into()?;
-        Ok(doc)
+            .map(TryInto::try_into)
+            .transpose()
+    }
+
+    pub async fn load_definition_metadata(
+        &mut self,
+        id: ComponentDefinitionId,
+    ) -> anyhow::Result<ComponentDefinitionMetadata> {
+        match self.load_definition(id).await? {
+            Some(doc) => Ok(doc.into_value()),
+            None => {
+                if id.is_root() {
+                    // The root component's metadata document may be missing if the app hasn't been
+                    // updated to use components.
+                    Ok(ComponentDefinitionMetadata {
+                        path: ComponentDefinitionPath::root(),
+                        definition_type: ComponentDefinitionType::App,
+                        child_components: Vec::new(),
+                        exports: BTreeMap::new(),
+                    })
+                } else {
+                    anyhow::bail!(ErrorMetadata::bad_request(
+                        "InvalidReference",
+                        format!("Component definition {:?} not found", id),
+                    ))
+                }
+            },
+        }
     }
 
     pub async fn load_all_definitions(

crates/isolate/src/environment/action/mod.rs

@@ -250,7 +250,6 @@ impl<RT: Runtime> ActionEnvironment<RT> {
         let (task_retval_sender, task_responses) = mpsc::unbounded();
         let resources = Arc::new(Mutex::new(BTreeMap::new()));
         let task_executor = TaskExecutor {
-            component: component.clone(),
             rt: rt.clone(),
             identity: identity.clone(),
             file_storage,

crates/isolate/src/environment/action/phase.rs

@@ -10,7 +10,6 @@ use common::{
         ComponentPath,
         Reference,
         Resource,
-        COMPONENTS_ENABLED,
     },
     runtime::{
         Runtime,
@@ -162,16 +161,12 @@ impl<RT: Runtime> ActionPhase<RT> {
             let source_package = SourcePackageModel::new(&mut tx, component_id.into())
                 .get_latest()
                 .await?;
-            if !*COMPONENTS_ENABLED {
-                anyhow::ensure!(self.component.is_root());
-            } else {
-                let loaded_resources = ComponentsModel::new(&mut tx)
-                    .preload_resources(component_id)
-                    .await?;
-                {
-                    let mut resources = resources.lock();
-                    *resources = loaded_resources;
-                }
+            let loaded_resources = ComponentsModel::new(&mut tx)
+                .preload_resources(component_id)
+                .await?;
+            {
+                let mut resources = resources.lock();
+                *resources = loaded_resources;
             }
             Ok((module_metadata, source_package))
         })

crates/isolate/src/environment/action/task_executor.rs

@@ -7,10 +7,8 @@ use std::{
 use common::{
     components::{
         ComponentFunctionPath,
-        ComponentPath,
         Reference,
         Resource,
-        COMPONENTS_ENABLED,
     },
     execution_context::ExecutionContext,
     http::fetch::FetchClient,
@@ -67,7 +65,6 @@ use crate::{
 pub struct TaskExecutor<RT: Runtime> {
     pub rt: RT,
     pub identity: Identity,
-    pub component: ComponentPath,
     pub file_storage: TransactionalFileStorage<RT>,
     pub syscall_trace: Arc<Mutex<SyscallTrace>>,
     pub action_callbacks: Arc<dyn ActionCallbacks>,
@@ -196,17 +193,7 @@ impl<RT: Runtime> TaskExecutor<RT> {
     }
 
     pub fn resolve(&self, reference: &Reference) -> anyhow::Result<Resource> {
-        let resource = if !*COMPONENTS_ENABLED {
-            match reference {
-                Reference::Function(p) if self.component.is_root() => {
-                    Resource::Function(ComponentFunctionPath {
-                        component: ComponentPath::root(),
-                        udf_path: p.clone(),
-                    })
-                },
-                r => anyhow::bail!("Invalid reference {r:?} with components disabled"),
-            }
-        } else {
+        let resource = {
             let resources = self.resources.lock();
             resources
                 .get(reference)

crates/model/src/components/mod.rs

@@ -56,17 +56,10 @@ impl<'a, RT: Runtime> ComponentsModel<'a, RT> {
                     [attribute] => attribute,
                     _ => anyhow::bail!("Nested component argument references unsupported"),
                 };
-                let component = BootstrapComponentsModel::new(self.tx)
-                    .load_component(component_id)
-                    .await?
-                    .ok_or_else(|| {
-                        ErrorMetadata::bad_request(
-                            "InvalidReference",
-                            format!("Component {:?} not found", component_id),
-                        )
-                    })?;
-                let ComponentType::ChildComponent { ref args, .. } = component.component_type
-                else {
+                let component_type = BootstrapComponentsModel::new(self.tx)
+                    .load_component_type(component_id)
+                    .await?;
+                let ComponentType::ChildComponent { ref args, .. } = component_type else {
                     anyhow::bail!(ErrorMetadata::bad_request(
                         "InvalidReference",
                         "Can't use an argument reference in the app"
@@ -160,7 +153,7 @@ impl<'a, RT: Runtime> ComponentsModel<'a, RT> {
     ) -> anyhow::Result<Resource> {
         let mut m = BootstrapComponentsModel::new(self.tx);
         let definition_id = m.component_definition(component_id).await?;
-        let definition = m.load_definition(definition_id).await?;
+        let definition = m.load_definition_metadata(definition_id).await?;
 
         let mut current = &definition.exports;
         let mut attribute_iter = attributes.iter();
@@ -193,19 +186,15 @@ impl<'a, RT: Runtime> ComponentsModel<'a, RT> {
         component_id: ComponentId,
     ) -> anyhow::Result<BTreeMap<Reference, Resource>> {
         let mut m = BootstrapComponentsModel::new(self.tx);
-        let component = m.load_component(component_id).await?.ok_or_else(|| {
-            ErrorMetadata::bad_request(
-                "InvalidReference",
-                format!("Component {:?} not found", component_id),
-            )
-        })?;
+        let component = m.load_component(component_id).await?;
+        let component_type = m.load_component_type(component_id).await?;
         let definition_id = m.component_definition(component_id).await?;
-        let definition = m.load_definition(definition_id).await?;
+        let definition = m.load_definition_metadata(definition_id).await?;
         let component_path = m.get_component_path(component_id).await?;
 
         let mut result = BTreeMap::new();
 
-        if let ComponentType::ChildComponent { ref args, .. } = component.component_type {
+        if let ComponentType::ChildComponent { ref args, .. } = component_type {
             for (name, resource) in args {
                 let reference = Reference::ComponentArgument {
                     attributes: vec![name.clone()],
@@ -236,21 +225,23 @@ impl<'a, RT: Runtime> ComponentsModel<'a, RT> {
             }
         }
 
-        for instantiation in &definition.child_components {
-            let parent = (component.id().internal_id(), instantiation.name.clone());
-            let child_component = BootstrapComponentsModel::new(self.tx)
-                .component_in_parent(Some(parent))
-                .await?
-                .context("Missing child component")?;
-            let child_component_id = ComponentId::Child(child_component.id().internal_id());
-            for (attributes, resource) in
-                self.preload_exported_resources(child_component_id).await?
-            {
-                let reference = Reference::ChildComponent {
-                    component: instantiation.name.clone(),
-                    attributes,
-                };
-                result.insert(reference, resource);
+        if let Some(component) = component {
+            for instantiation in &definition.child_components {
+                let parent = (component.id().internal_id(), instantiation.name.clone());
+                let child_component = BootstrapComponentsModel::new(self.tx)
+                    .component_in_parent(Some(parent))
+                    .await?
+                    .context("Missing child component")?;
+                let child_component_id = ComponentId::Child(child_component.id().internal_id());
+                for (attributes, resource) in
+                    self.preload_exported_resources(child_component_id).await?
+                {
+                    let reference = Reference::ChildComponent {
+                        component: instantiation.name.clone(),
+                        attributes,
+                    };
+                    result.insert(reference, resource);
+                }
             }
         }
 
@@ -263,7 +254,7 @@ impl<'a, RT: Runtime> ComponentsModel<'a, RT> {
     ) -> anyhow::Result<BTreeMap<Vec<Identifier>, Resource>> {
         let mut m = BootstrapComponentsModel::new(self.tx);
         let definition_id = m.component_definition(component_id).await?;
-        let definition = m.load_definition(definition_id).await?;
+        let definition = m.load_definition_metadata(definition_id).await?;
 
         let mut stack = vec![(vec![], &definition.exports)];
         let mut result = BTreeMap::new();