Wait for database to load before returning schema (#4551)

## Summary

When hitting `/v1/schema` while a database is still loading (replaying
the log, running init reducers, etc.), the endpoint returned a 500 error
because the module host was not yet available.

## Changes

- Add `Host::wait_for_module(timeout)` in `crates/client-api/src/lib.rs`
-- polls `get_module_host` with exponential backoff (100ms, 200ms,
400ms, 800ms, 1s, 1s, ...) up to the given timeout
- Update the `/v1/schema` route to use `wait_for_module(10s)` instead of
the immediate `module()` call

If the database finishes loading within 10 seconds, the schema is
returned normally. If it does not load in time, the existing 500 error
is returned (same behavior as before, just delayed).

No other routes are changed -- this is scoped to the schema endpoint per
the issue description. Other routes (SQL, call, etc.) could adopt the
same pattern if needed.

Fixes clockworklabs/SpacetimeDBPrivate#2748

Co-authored-by: clockwork-labs-bot <clockwork-labs-bot@users.noreply.github.com>

Author: clockwork-labs-bot

crates/client-api/src/lib.rs

@@ -107,6 +107,29 @@ impl Host {
         self.host_controller.get_module_host(self.replica_id).await
     }
 
+    /// Wait for the module host to become available, retrying with backoff.
+    ///
+    /// This is useful for routes like `/schema` that may be called while the
+    /// database is still loading. Instead of returning an immediate 500, we
+    /// poll for up to `timeout` before giving up.
+    pub async fn wait_for_module(&self, timeout: std::time::Duration) -> Result<ModuleHost, NoSuchModule> {
+        let deadline = tokio::time::Instant::now() + timeout;
+        let mut interval = tokio::time::Duration::from_millis(100);
+        loop {
+            match self.host_controller.get_module_host(self.replica_id).await {
+                Ok(module) => return Ok(module),
+                Err(NoSuchModule) => {
+                    if tokio::time::Instant::now() >= deadline {
+                        return Err(NoSuchModule);
+                    }
+                    tokio::time::sleep(interval).await;
+                    // Exponential backoff: 100ms, 200ms, 400ms, 800ms, 1s, 1s, ...
+                    interval = (interval * 2).min(tokio::time::Duration::from_secs(1));
+                }
+            }
+        }
+    }
+
     pub async fn module_watcher(&self) -> Result<watch::Receiver<ModuleHost>, NoSuchModule> {
         self.host_controller.watch_module_host(self.replica_id).await
     }

crates/client-api/src/routes/database.rs

@@ -341,7 +341,14 @@ pub async fn schema<S>(
 where
     S: ControlStateDelegate + NodeDelegate,
 {
-    let (module, _) = find_module_and_database(&worker_ctx, name_or_identity).await?;
+    let (leader, _) = find_leader_and_database(&worker_ctx, name_or_identity).await?;
+    // Wait for the module to finish loading rather than returning an immediate
+    // 500 error. The database may still be initializing (replaying the log,
+    // running init reducers, etc.).
+    let module = leader
+        .wait_for_module(std::time::Duration::from_secs(10))
+        .await
+        .map_err(log_and_500)?;
 
     let module_def = &module.info.module_def;
     let response_json = match version {