Simplify default SQLite database handling.

Instead of treating the SQLite Factor's runtime config as 1 on 1 the
same as the Spin CLI runtime config toml, we inject handling of the
"default" label into the factor's runtime config struct. This makes
handling of label resolution happen in just one place instead of
spliting it into two.

Signed-off-by: Ryan Levick <[email protected]>

Author: rylev

crates/factor-sqlite/src/lib.rs

@@ -15,18 +15,13 @@ use spin_world::v2::sqlite as v2;
 pub use runtime_config::RuntimeConfig;
 
 pub struct SqliteFactor {
-    default_label_resolver: Arc<dyn DefaultLabelResolver>,
+    _priv: (),
 }
 
 impl SqliteFactor {
     /// Create a new `SqliteFactor`
-    ///
-    /// Takes a `default_label_resolver` for how to handle when a database label doesn't
-    /// have a corresponding runtime configuration.
-    pub fn new(default_label_resolver: impl DefaultLabelResolver + 'static) -> Self {
-        Self {
-            default_label_resolver: Arc::new(default_label_resolver),
-        }
+    pub fn new() -> Self {
+        Self { _priv: () }
     }
 }
 
@@ -69,13 +64,8 @@ impl Factor for SqliteFactor {
                 ))
             })
             .collect::<anyhow::Result<HashMap<_, _>>>()?;
-        let resolver = self.default_label_resolver.clone();
-        let get_connection_creator: host::ConnectionCreatorGetter = Arc::new(move |label| {
-            connection_creators
-                .get(label)
-                .cloned()
-                .or_else(|| resolver.default(label))
-        });
+        let get_connection_creator: host::ConnectionCreatorGetter =
+            Arc::new(move |label| connection_creators.get(label).cloned());
 
         ensure_allowed_databases_are_configured(&allowed_databases, |label| {
             get_connection_creator(label).is_some()
@@ -138,14 +128,6 @@ fn ensure_allowed_databases_are_configured(
 /// Metadata key for a list of allowed databases for a component.
 pub const ALLOWED_DATABASES_KEY: MetadataKey<Vec<String>> = MetadataKey::new("databases");
 
-/// Resolves a label to a default connection creator.
-pub trait DefaultLabelResolver: Send + Sync {
-    /// If there is no runtime configuration for a given database label, return a default connection creator.
-    ///
-    /// If `Option::None` is returned, the database is not allowed.
-    fn default(&self, label: &str) -> Option<Arc<dyn ConnectionCreator>>;
-}
-
 #[derive(Clone)]
 pub struct AppState {
     /// A map from component id to a set of allowed database labels.

crates/factor-sqlite/tests/factor_test.rs

@@ -17,9 +17,8 @@ struct TestFactors {
 
 #[tokio::test]
 async fn sqlite_works() -> anyhow::Result<()> {
-    let test_resolver = DefaultLabelResolver::new(Some("default"));
     let factors = TestFactors {
-        sqlite: SqliteFactor::new(test_resolver),
+        sqlite: SqliteFactor::new(),
     };
     let env = TestEnvironment::new(factors).extend_manifest(toml! {
         [component.test-component]
@@ -38,9 +37,8 @@ async fn sqlite_works() -> anyhow::Result<()> {
 
 #[tokio::test]
 async fn errors_when_non_configured_database_used() -> anyhow::Result<()> {
-    let test_resolver = DefaultLabelResolver::new(None);
     let factors = TestFactors {
-        sqlite: SqliteFactor::new(test_resolver),
+        sqlite: SqliteFactor::new(),
     };
     let env = TestEnvironment::new(factors).extend_manifest(toml! {
         [component.test-component]
@@ -60,9 +58,8 @@ async fn errors_when_non_configured_database_used() -> anyhow::Result<()> {
 
 #[tokio::test]
 async fn no_error_when_database_is_configured() -> anyhow::Result<()> {
-    let test_resolver = DefaultLabelResolver::new(None);
     let factors = TestFactors {
-        sqlite: SqliteFactor::new(test_resolver),
+        sqlite: SqliteFactor::new(),
     };
     let runtime_config = toml! {
         [sqlite_database.foo]
@@ -119,28 +116,6 @@ impl TryFrom<TomlRuntimeSource<'_>> for TestFactorsRuntimeConfig {
     }
 }
 
-/// Will return an `InvalidConnectionCreator` for the supplied default database.
-struct DefaultLabelResolver {
-    default: Option<String>,
-}
-
-impl DefaultLabelResolver {
-    fn new(default: Option<&str>) -> Self {
-        Self {
-            default: default.map(Into::into),
-        }
-    }
-}
-
-impl spin_factor_sqlite::DefaultLabelResolver for DefaultLabelResolver {
-    fn default(&self, label: &str) -> Option<Arc<dyn spin_factor_sqlite::ConnectionCreator>> {
-        let Some(default) = &self.default else {
-            return None;
-        };
-        (default == label).then_some(Arc::new(InvalidConnectionCreator))
-    }
-}
-
 /// A connection creator that always returns an error.
 struct InvalidConnectionCreator;
 

crates/runtime-config/src/lib.rs

@@ -368,7 +368,18 @@ impl FactorRuntimeConfigSource<OutboundMqttFactor> for TomlRuntimeConfigSource<'
 
 impl FactorRuntimeConfigSource<SqliteFactor> for TomlRuntimeConfigSource<'_, '_> {
     fn get_runtime_config(&mut self) -> anyhow::Result<Option<spin_factor_sqlite::RuntimeConfig>> {
-        self.sqlite.resolve_from_toml(&self.toml.table)
+        Ok(self
+            .sqlite
+            .resolve_from_toml(&self.toml.table)?
+            .map(|mut config| {
+                // If the user did not provide configuration for the default label, add it.
+                if !config.connection_creators.contains_key("default") {
+                    config
+                        .connection_creators
+                        .insert("default".to_owned(), self.sqlite.default());
+                }
+                config
+            }))
     }
 }
 

crates/runtime-factors/src/build.rs

@@ -39,7 +39,6 @@ impl RuntimeFactorsBuilder for FactorsBuilder {
             config.working_dir.clone(),
             args.allow_transient_write,
             runtime_config.key_value_resolver.clone(),
-            runtime_config.sqlite_resolver.clone(),
             use_gpu,
         )
         .context("failed to create factors")?;

crates/runtime-factors/src/lib.rs

@@ -41,7 +41,6 @@ impl TriggerFactors {
         working_dir: impl Into<PathBuf>,
         allow_transient_writes: bool,
         default_key_value_label_resolver: impl spin_factor_key_value::DefaultLabelResolver + 'static,
-        default_sqlite_label_resolver: impl spin_factor_sqlite::DefaultLabelResolver + 'static,
         use_gpu: bool,
     ) -> anyhow::Result<Self> {
         Ok(Self {
@@ -50,7 +49,7 @@ impl TriggerFactors {
             key_value: KeyValueFactor::new(default_key_value_label_resolver),
             outbound_networking: outbound_networking_factor(),
             outbound_http: OutboundHttpFactor::default(),
-            sqlite: SqliteFactor::new(default_sqlite_label_resolver),
+            sqlite: SqliteFactor::new(),
             redis: OutboundRedisFactor::new(),
             mqtt: OutboundMqttFactor::new(NetworkedMqttClient::creator()),
             pg: OutboundPgFactor::new(),

crates/sqlite/src/lib.rs

@@ -6,7 +6,7 @@ use std::{
 };
 
 use serde::Deserialize;
-use spin_factor_sqlite::{ConnectionCreator, DefaultLabelResolver};
+use spin_factor_sqlite::ConnectionCreator;
 use spin_factors::{
     anyhow::{self, Context as _},
     runtime_config::toml::GetTomlValue,
@@ -97,13 +97,9 @@ pub struct TomlRuntimeConfig {
     pub config: toml::Table,
 }
 
-impl DefaultLabelResolver for RuntimeConfigResolver {
-    fn default(&self, label: &str) -> Option<Arc<dyn ConnectionCreator>> {
-        // Only default the database labeled "default".
-        if label != "default" {
-            return None;
-        }
-
+impl RuntimeConfigResolver {
+    /// The [`ConnectionCreator`] for the 'default' label.
+    pub fn default(&self) -> Arc<dyn ConnectionCreator> {
         let path = self
             .default_database_dir
             .as_deref()
@@ -113,7 +109,7 @@ impl DefaultLabelResolver for RuntimeConfigResolver {
             let connection = spin_sqlite_inproc::InProcConnection::new(location)?;
             Ok(Box::new(connection) as _)
         };
-        Some(Arc::new(factory))
+        Arc::new(factory)
     }
 }