Add a recursive mounts fields to ModuleDef that references submodules.

Author: aasoni

crates/bindings-csharp/Runtime/Internal/Autogen/RawModuleDefV10Section.g.cs

@@ -89,6 +89,17 @@ pub enum RawModuleDefV10Section {
 
     /// Names provided explicitly by the user that do not follow from the case conversion policy.
     ExplicitNames(ExplicitNames),
+
+    /// Mounted submodules, keyed by the namespace they are mounted under.
+    Mounts(Vec<RawModuleMountV10>),
+}
+
+#[derive(Debug, Clone, SpacetimeType)]
+#[sats(crate = crate)]
+#[cfg_attr(feature = "test", derive(PartialEq, Eq, PartialOrd, Ord))]
+pub struct RawModuleMountV10 {
+    pub namespace: String,
+    pub module: RawModuleDefV10,
 }
 
 #[derive(Debug, Clone, Copy, Default, SpacetimeType)]
@@ -510,6 +521,14 @@ pub struct RawViewDefV10 {
 }
 
 impl RawModuleDefV10 {
+    /// Get the mounted submodules for this module definition.
+    pub fn mounts(&self) -> Option<&Vec<RawModuleMountV10>> {
+        self.sections.iter().find_map(|s| match s {
+            RawModuleDefV10Section::Mounts(mounts) => Some(mounts),
+            _ => None,
+        })
+    }
+
     /// Get the types section, if present.
     pub fn types(&self) -> Option<&Vec<RawTypeDefV10>> {
         self.sections.iter().find_map(|s| match s {

crates/bindings-csharp/Runtime/Internal/Autogen/RawModuleMountV10.g.cs

@@ -33,8 +33,8 @@ use spacetimedb_data_structures::map::{Equivalent, HashMap};
 use spacetimedb_lib::db::raw_def;
 use spacetimedb_lib::db::raw_def::v10::{
     ExplicitNames, RawConstraintDefV10, RawIndexDefV10, RawLifeCycleReducerDefV10, RawModuleDefV10,
-    RawModuleDefV10Section, RawProcedureDefV10, RawReducerDefV10, RawRowLevelSecurityDefV10, RawScheduleDefV10,
-    RawScopedTypeNameV10, RawSequenceDefV10, RawTableDefV10, RawTypeDefV10, RawViewDefV10,
+    RawModuleDefV10Section, RawModuleMountV10, RawProcedureDefV10, RawReducerDefV10, RawRowLevelSecurityDefV10,
+    RawScheduleDefV10, RawScopedTypeNameV10, RawSequenceDefV10, RawTableDefV10, RawTypeDefV10, RawViewDefV10,
 };
 use spacetimedb_lib::db::raw_def::v9::{
     Lifecycle, RawColumnDefaultValueV9, RawConstraintDataV9, RawConstraintDefV9, RawIndexAlgorithm, RawIndexDefV9,
@@ -151,6 +151,9 @@ pub struct ModuleDef {
     /// was authored under.
     #[allow(unused)]
     raw_module_def_version: RawModuleDefVersion,
+
+    /// Mounted submodules, keyed by the namespace they are mounted under.
+    mounts: IndexMap<String, ModuleDef>,
 }
 
 #[derive(Debug, Clone, Copy, Eq, PartialEq)]
@@ -167,6 +170,11 @@ impl ModuleDef {
         self.raw_module_def_version
     }
 
+    /// The mounted submodules of the module definition.
+    pub fn mounts(&self) -> &IndexMap<String, ModuleDef> {
+        &self.mounts
+    }
+
     /// The tables of the module definition.
     pub fn tables(&self) -> impl Iterator<Item = &TableDef> {
         self.tables.values()
@@ -437,6 +445,7 @@ impl From<ModuleDef> for RawModuleDefV9 {
             row_level_security_raw,
             procedures,
             raw_module_def_version: _,
+            mounts: _,
         } = val;
 
         // Extract column defaults from tables before consuming tables
@@ -493,6 +502,7 @@ impl From<ModuleDef> for RawModuleDefV10 {
             row_level_security_raw,
             procedures,
             raw_module_def_version: _,
+            mounts,
         } = val;
 
         let mut sections = Vec::new();
@@ -605,6 +615,17 @@ impl From<ModuleDef> for RawModuleDefV10 {
         // Always emit ExplicitNames so canonical names survive the round-trip.
         sections.push(RawModuleDefV10Section::ExplicitNames(explicit_names));
 
+        let mounts: Vec<_> = mounts
+            .into_iter()
+            .map(|(namespace, module)| RawModuleMountV10 {
+                namespace,
+                module: module.into(),
+            })
+            .collect();
+        if !mounts.is_empty() {
+            sections.push(RawModuleDefV10Section::Mounts(mounts));
+        }
+
         RawModuleDefV10 { sections }
     }
 }

crates/lib/src/db/raw_def/v10.rs

@@ -81,6 +81,12 @@ pub fn validate(def: RawModuleDefV10) -> Result<ModuleDef> {
         .cloned()
         .map(ExplicitNamesLookup::new)
         .unwrap_or_default();
+    let mounts = def
+        .mounts()
+        .into_iter()
+        .flat_map(|mounts| mounts.iter().cloned())
+        .map(validate_mount)
+        .collect_all_errors::<Vec<_>>();
 
     // Original `typespace` needs to be preserved to be assign `accesor_name`s to columns.
     let typespace_with_accessor_names = typespace.clone();
@@ -263,8 +269,12 @@ pub fn validate(def: RawModuleDefV10) -> Result<ModuleDef> {
         .map(|rls| (rls.sql.clone(), rls.to_owned()))
         .collect();
 
-    let (tables, types, reducers, procedures, views) =
-        (tables_types_reducers_procedures_views).map_err(|errors| errors.sort_deduplicate())?;
+    let (tables, types, reducers, procedures, views, mounts) = (tables_types_reducers_procedures_views, mounts)
+        .combine_errors()
+        .and_then(|((tables, types, reducers, procedures, views), mounts)| {
+            validate_mount_names_are_unique(mounts).map(|mounts| (tables, types, reducers, procedures, views, mounts))
+        })
+        .map_err(|errors: ValidationErrors| errors.sort_deduplicate())?;
 
     let typespace_for_generate = typespace_for_generate.finish();
 
@@ -281,9 +291,32 @@ pub fn validate(def: RawModuleDefV10) -> Result<ModuleDef> {
         lifecycle_reducers,
         procedures,
         raw_module_def_version: RawModuleDefVersion::V10,
+        mounts,
     })
 }
 
+fn validate_mount(mount: RawModuleMountV10) -> Result<(String, ModuleDef)> {
+    Identifier::new(mount.namespace.clone().into())
+        .map_err(|error| ValidationErrors::from(ValidationError::IdentifierError { error }))?;
+
+    Ok((mount.namespace, validate(mount.module)?))
+}
+
+fn validate_mount_names_are_unique(mounts: Vec<(String, ModuleDef)>) -> Result<IndexMap<String, ModuleDef>> {
+    let mut errors = vec![];
+    let mut map = IndexMap::with_capacity(mounts.len());
+
+    for (namespace, def) in mounts {
+        if map.contains_key(&namespace) {
+            errors.push(ValidationError::DuplicateName { name: namespace.into() });
+        } else {
+            map.insert(namespace, def);
+        }
+    }
+
+    ValidationErrors::add_extra_errors(Ok(map), errors)
+}
+
 /// Change the visibility of scheduled functions and lifecycle reducers to Internal.
 ///
 fn change_scheduled_functions_and_lifetimes_visibility(
@@ -882,11 +915,14 @@ mod tests {
 
     use itertools::Itertools;
     use spacetimedb_data_structures::expect_error_matching;
-    use spacetimedb_lib::db::raw_def::v10::{CaseConversionPolicy, RawModuleDefV10Builder};
+    use spacetimedb_lib::db::raw_def::v10::{
+        CaseConversionPolicy, RawModuleDefV10, RawModuleDefV10Builder, RawModuleDefV10Section, RawModuleMountV10,
+    };
     use spacetimedb_lib::db::raw_def::v9::{btree, direct, hash};
     use spacetimedb_lib::db::raw_def::*;
     use spacetimedb_lib::ScheduleAt;
     use spacetimedb_primitives::{ColId, ColList, ColSet};
+    use spacetimedb_sats::raw_identifier::RawIdentifier;
     use spacetimedb_sats::{AlgebraicType, AlgebraicTypeRef, AlgebraicValue, ProductType, SumValue};
     use v9::{Lifecycle, TableAccess, TableType};
 
@@ -1261,6 +1297,66 @@ mod tests {
         });
     }
 
+    #[test]
+    fn validates_mounted_submodules_recursively() {
+        let mut mounted_builder = RawModuleDefV10Builder::new();
+        mounted_builder
+            .build_table_with_new_type("Sessions", ProductType::from([("id", AlgebraicType::U64)]), true)
+            .finish();
+
+        let raw = RawModuleDefV10 {
+            sections: vec![RawModuleDefV10Section::Mounts(vec![RawModuleMountV10 {
+                namespace: "authlib".to_string(),
+                module: mounted_builder.finish(),
+            }])],
+        };
+
+        let def: ModuleDef = raw.try_into().expect("mounted module should validate");
+        let mounts = def.mounts();
+
+        assert_eq!(mounts.len(), 1);
+        let mounted = mounts.get("authlib").expect("authlib mount should exist");
+        assert!(mounted.table(&expect_identifier("sessions")).is_some());
+    }
+
+    #[test]
+    fn invalid_mount_namespace() {
+        let raw = RawModuleDefV10 {
+            sections: vec![RawModuleDefV10Section::Mounts(vec![RawModuleMountV10 {
+                namespace: "".to_string(),
+                module: RawModuleDefV10::default(),
+            }])],
+        };
+
+        let result: Result<ModuleDef> = raw.try_into();
+
+        expect_error_matching!(result, ValidationError::IdentifierError { error } => {
+            error == &IdentifierError::Empty {}
+        });
+    }
+
+    #[test]
+    fn duplicate_mount_namespace() {
+        let raw = RawModuleDefV10 {
+            sections: vec![RawModuleDefV10Section::Mounts(vec![
+                RawModuleMountV10 {
+                    namespace: "authlib".to_string(),
+                    module: RawModuleDefV10::default(),
+                },
+                RawModuleMountV10 {
+                    namespace: "authlib".to_string(),
+                    module: RawModuleDefV10::default(),
+                },
+            ])],
+        };
+
+        let result: Result<ModuleDef> = raw.try_into();
+
+        expect_error_matching!(result, ValidationError::DuplicateName { name } => {
+            name == &RawIdentifier::from("authlib")
+        });
+    }
+
     #[test]
     fn invalid_unique_constraint_column_ref() {
         let mut builder = RawModuleDefV10Builder::new();

crates/schema/src/def.rs

@@ -166,6 +166,7 @@ pub fn validate(def: RawModuleDefV9) -> Result<ModuleDef> {
         lifecycle_reducers,
         procedures,
         raw_module_def_version: RawModuleDefVersion::V9OrEarlier,
+        mounts: IndexMap::new(),
     })
 }