replace ComponentId::Root with TODOs (#26879)

GitOrigin-RevId: ea63af8d137051d9c3b9c658724cf4ed3f85ad3d

Author: ldanilek

crates/application/src/cron_jobs/mod.rs

@@ -390,7 +390,7 @@ impl<RT: Runtime> CronJobExecutor<RT> {
         let execution_time_f64 = execution_time.as_secs_f64();
         let truncated_log_lines = self.truncate_log_lines(outcome.log_lines.clone());
 
-        let mut model = CronModel::new(&mut tx, ComponentId::Root);
+        let mut model = CronModel::new(&mut tx, ComponentId::TODO());
 
         if let Ok(ref result) = outcome.result {
             let truncated_result = self.truncate_result(result.clone());
@@ -435,7 +435,7 @@ impl<RT: Runtime> CronJobExecutor<RT> {
                 // Continue without updating since the job state has changed
                 return Ok(());
             };
-            let mut model = CronModel::new(&mut tx, ComponentId::Root);
+            let mut model = CronModel::new(&mut tx, ComponentId::TODO());
             let status = CronJobStatus::Err(e.to_string());
             model
                 .insert_cron_job_log(&job, status, truncated_log_lines, execution_time_f64)
@@ -482,7 +482,7 @@ impl<RT: Runtime> CronJobExecutor<RT> {
                 // Set state to in progress
                 let mut updated_job = job.clone();
                 updated_job.state = CronJobState::InProgress;
-                CronModel::new(&mut tx, ComponentId::Root)
+                CronModel::new(&mut tx, ComponentId::TODO())
                     .update_job_state(job_id, updated_job.clone())
                     .await?;
                 self.database
@@ -560,7 +560,7 @@ impl<RT: Runtime> CronJobExecutor<RT> {
                 // guess the correct behavior here is to store the executionId in the state so
                 // we can log correctly here.
                 let context = ExecutionContext::new(request_id, &caller);
-                let mut model = CronModel::new(&mut tx, ComponentId::Root);
+                let mut model = CronModel::new(&mut tx, ComponentId::TODO());
                 model
                     .insert_cron_job_log(&job, status, log_lines, 0.0)
                     .await?;
@@ -638,7 +638,7 @@ impl<RT: Runtime> CronJobExecutor<RT> {
             // Continue without updating since the job state has changed
             return Ok(());
         };
-        let mut model = CronModel::new(&mut tx, ComponentId::Root);
+        let mut model = CronModel::new(&mut tx, ComponentId::TODO());
         model
             .insert_cron_job_log(expected_state, status, log_lines, execution_time)
             .await?;

crates/application/src/lib.rs

@@ -802,7 +802,7 @@ impl<RT: Runtime> Application<RT> {
     ) -> anyhow::Result<Option<String>> {
         let mut tx = self.begin(identity).await?;
         let path = CanonicalizedComponentModulePath {
-            component: ComponentId::Root,
+            component: ComponentId::TODO(),
             module_path: path.canonicalize(),
         };
         let Some(metadata) = ModuleModel::new(&mut tx).get_metadata(path.clone()).await? else {

crates/application/src/test_helpers.rs

@@ -89,7 +89,7 @@ use crate::{
 };
 
 pub static OBJECTS_TABLE: LazyLock<TableName> = LazyLock::new(|| "objects".parse().unwrap());
-pub static OBJECTS_TABLE_COMPONENT: ComponentId = ComponentId::Root;
+pub static OBJECTS_TABLE_COMPONENT: ComponentId = ComponentId::test_user();
 
 #[derive(Default)]
 pub struct ApplicationFixtureArgs {

crates/application/src/tests/cron_jobs.rs

@@ -66,7 +66,7 @@ async fn create_cron_job(
     BTreeMap<CronIdentifier, ParsedDocument<CronJob>>,
     CronModel<TestRuntime>,
 )> {
-    let mut cron_model = CronModel::new(tx, ComponentId::Root);
+    let mut cron_model = CronModel::new(tx, ComponentId::test_user());
     let mut map = serde_json::Map::new();
     map.insert(
         "key".to_string(),
@@ -221,7 +221,7 @@ async fn test_cron_jobs_helper(rt: TestRuntime, backend_state: BackendState) ->
             .table_is_empty(OBJECTS_TABLE_COMPONENT.into(), &OBJECTS_TABLE)
             .await?
     );
-    let mut logs_query = cron_log_query(&mut tx, ComponentId::Root)?;
+    let mut logs_query = cron_log_query(&mut tx, ComponentId::test_user())?;
     assert!(logs_query.next(&mut tx, Some(1)).await?.is_none());
 
     // Resuming the backend should make the jobs execute.

crates/application/src/tests/source_package.rs

@@ -73,7 +73,7 @@ pub async fn assemble_package<RT: Runtime>(
     modifications: BTreeMap<CanonicalizedModulePath, Option<ModuleConfig>>,
 ) -> anyhow::Result<Vec<ModuleConfig>> {
     let existing_modules = ModuleModel::new(tx)
-        .get_application_modules(ComponentId::Root, module_loader)
+        .get_application_modules(ComponentId::TODO(), module_loader)
         .await?;
     let mut modules = BTreeMap::new();
     for (path, module) in existing_modules {

crates/common/src/components/mod.rs

@@ -53,6 +53,21 @@ impl ComponentId {
     pub fn is_root(&self) -> bool {
         matches!(self, ComponentId::Root)
     }
+
+    /// This component should be passed in somehow -- it's not always going to
+    /// be Root.
+    #[allow(non_snake_case)]
+    pub const fn TODO() -> Self {
+        ComponentId::Root
+    }
+
+    /// Component for tests where we need a user component.
+    /// Ideally we could switch this to some other component with no test
+    /// breakage.
+    #[cfg(any(test, feature = "testing"))]
+    pub const fn test_user() -> Self {
+        ComponentId::Root
+    }
 }
 
 impl From<ComponentId> for TableNamespace {

crates/isolate/src/isolate2/runner.rs

@@ -504,7 +504,7 @@ async fn run_request<RT: Runtime>(
         while let Some(module_path) = stack.pop() {
             let module_specifier = module_specifier_from_path(&module_path)?;
             let path = CanonicalizedComponentModulePath {
-                component: ComponentId::Root,
+                component: ComponentId::TODO(),
                 module_path: module_path.clone(),
             };
             let Some(module_metadata) = module_loader.get_module(tx, path).await? else {
@@ -842,7 +842,7 @@ impl<'a, RT: Runtime> AsyncSyscallProvider<RT> for Isolate2SyscallProvider<'a, R
 
     fn component(&self) -> anyhow::Result<ComponentId> {
         // TODO(lee) fix when we finish isolate2.
-        Ok(ComponentId::Root)
+        Ok(ComponentId::TODO())
     }
 
     fn key_broker(&self) -> &KeyBroker {

crates/isolate/src/tests/analyze.rs

@@ -50,7 +50,7 @@ async fn test_analyze_module(rt: TestRuntime) -> anyhow::Result<()> {
     let modules = {
         let mut tx = t.database.begin(Identity::system()).await?;
         ModuleModel::new(&mut tx)
-            .get_application_modules(ComponentId::Root, t.module_loader.as_ref())
+            .get_application_modules(ComponentId::test_user(), t.module_loader.as_ref())
             .await?
     };
 
@@ -209,7 +209,7 @@ async fn test_analyze_http_errors(rt: TestRuntime) -> anyhow::Result<()> {
         let mut modules = {
             let mut tx = t.database.begin(Identity::system()).await?;
             ModuleModel::new(&mut tx)
-                .get_application_modules(ComponentId::Root, t.module_loader.as_ref())
+                .get_application_modules(ComponentId::test_user(), t.module_loader.as_ref())
                 .await?
         };
 
@@ -246,7 +246,7 @@ async fn test_analyze_function(rt: TestRuntime) -> anyhow::Result<()> {
     let modules = {
         let mut tx = t.database.begin(Identity::system()).await?;
         ModuleModel::new(&mut tx)
-            .get_application_modules(ComponentId::Root, t.module_loader.as_ref())
+            .get_application_modules(ComponentId::test_user(), t.module_loader.as_ref())
             .await?
     };
 
@@ -336,7 +336,7 @@ async fn test_analyze_internal_function(rt: TestRuntime) -> anyhow::Result<()> {
     let modules = {
         let mut tx = t.database.begin(Identity::system()).await?;
         ModuleModel::new(&mut tx)
-            .get_application_modules(ComponentId::Root, t.module_loader.as_ref())
+            .get_application_modules(ComponentId::test_user(), t.module_loader.as_ref())
             .await?
     };
 
@@ -540,7 +540,7 @@ async fn test_analyze_imports_are_none(rt: TestRuntime) -> anyhow::Result<()> {
         let mut modules = {
             let mut tx = t.database.begin(Identity::system()).await?;
             ModuleModel::new(&mut tx)
-                .get_application_modules(ComponentId::Root, t.module_loader.as_ref())
+                .get_application_modules(ComponentId::test_user(), t.module_loader.as_ref())
                 .await?
         };
 

crates/model/src/config/mod.rs

@@ -89,7 +89,7 @@ impl<'a, RT: Runtime> ConfigModel<'a, RT> {
             None => None,
         };
 
-        let cron_diff = CronModel::new(self.tx, ComponentId::Root)
+        let cron_diff = CronModel::new(self.tx, ComponentId::TODO())
             .apply(&analyze_results)
             .await?;
 
@@ -104,7 +104,7 @@ impl<'a, RT: Runtime> ConfigModel<'a, RT> {
 
         let module_diff = ModuleModel::new(self.tx)
             .apply(
-                ComponentId::Root,
+                ComponentId::TODO(),
                 modules,
                 source_package_id,
                 analyze_results,

crates/model/src/source_packages/mod.rs

@@ -94,7 +94,7 @@ impl<'a, RT: Runtime> SourcePackageModel<'a, RT> {
         let mut source_package_ids = vec![];
 
         for module in ModuleModel::new(self.tx)
-            .get_all_metadata(ComponentId::Root)
+            .get_all_metadata(ComponentId::TODO())
             .await?
         {
             source_package_ids.push(module.source_package_id);