Merge branch 'jlarabie/csharp-view-ns' into rekhoff/csharp_replication_test_with_views

Author: rekhoff

crates/cli/src/config.rs

@@ -1114,10 +1114,12 @@ protocol =1
         let config_path = CliTomlPath::from_path_unchecked(tmp.path().join("config.toml"));
 
         let mut local = Config::load(config_path.clone()).unwrap();
-        let mut testnet = Config::load(config_path.clone()).unwrap();
+        let mut testnet = local.clone();
+        let mut maincloud = local.clone();
 
         local.home.default_server = Some("local".to_string());
         testnet.home.default_server = Some("testnet".to_string());
+        maincloud.home.default_server = Some("maincloud".to_string());
 
         let mut handles = vec![];
         let total_threads: usize = 8;
@@ -1154,11 +1156,12 @@ protocol =1
         }
         let local = local.doc().to_string();
         let testnet = testnet.doc().to_string();
+        let maincloud = maincloud.doc().to_string();
 
         // As long the results are any valid config, we're good.
         assert!(results
             .iter()
-            .all(|r| r.trim() == local.trim() || r.trim() == testnet.trim()));
+            .all(|r| r.trim() == local.trim() || r.trim() == testnet.trim() || r.trim() == maincloud.trim()));
         Ok(())
     }
 }

crates/cli/src/subcommands/generate.rs

@@ -252,7 +252,7 @@ pub async fn exec_ex(
         }
     }
 
-    if let Err(err) = lang.format_files(paths) {
+    if let Err(err) = lang.format_files(out_dir, paths) {
         // If we couldn't format the files, print a warning but don't fail the entire
         // task as the output should still be usable, just less pretty.
         eprintln!("Could not format generated files: {err}");
@@ -285,10 +285,10 @@ impl clap::ValueEnum for Language {
 }
 
 impl Language {
-    fn format_files(&self, generated_files: BTreeSet<PathBuf>) -> anyhow::Result<()> {
+    fn format_files(&self, project_dir: &PathBuf, generated_files: BTreeSet<PathBuf>) -> anyhow::Result<()> {
         match self {
             Language::Rust => rustfmt(generated_files)?,
-            Language::Csharp => dotnet_format(generated_files)?,
+            Language::Csharp => dotnet_format(project_dir, generated_files)?,
             Language::TypeScript => {
                 // TODO: implement formatting.
             }

crates/cli/src/tasks/csharp.rs

@@ -108,7 +108,7 @@ pub(crate) fn build_csharp(project_path: &Path, build_debug: bool) -> anyhow::Re
     anyhow::bail!("Built project successfully but couldn't find the output file.");
 }
 
-pub(crate) fn dotnet_format(files: impl IntoIterator<Item = PathBuf>) -> anyhow::Result<()> {
+pub(crate) fn dotnet_format(project_dir: &PathBuf, files: impl IntoIterator<Item = PathBuf>) -> anyhow::Result<()> {
     duct::cmd(
         "dotnet",
         itertools::chain(
@@ -128,6 +128,8 @@ pub(crate) fn dotnet_format(files: impl IntoIterator<Item = PathBuf>) -> anyhow:
             files.into_iter().map_into(),
         ),
     )
+    // This is important because we're running with `--folder`. We want to format the right folder!
+    .dir(project_dir)
     .run()?;
     Ok(())
 }

crates/cli/templates/basic-rust/client/src/main.rs

@@ -1,8 +1,9 @@
 mod module_bindings;
 use module_bindings::*;
 use std::env;
+use std::io::{self, Read};
 
-use spacetimedb_sdk::{DbConnection, Table};
+use spacetimedb_sdk::{DbContext, Table};
 
 fn main() {
     // The URI of the SpacetimeDB instance hosting our chat module.
@@ -14,28 +15,31 @@ fn main() {
     // Connect to the database
     let conn = DbConnection::builder()
         .with_module_name(db_name)
-        .with_host(host)
+        .with_uri(host)
         .on_connect(|_, _, _| {
             println!("Connected to SpacetimeDB");
         })
-        .on_connect_error(|e| {
+        .on_connect_error(|_ctx, e| {
             eprintln!("Connection error: {:?}", e);
             std::process::exit(1);
         })
         .build()
         .expect("Failed to connect");
 
+    conn.run_threaded();
+
     // Subscribe to the person table
-    conn.subscribe(&[
-        "SELECT * FROM person"
-    ]);
+    conn.subscription_builder()
+        .on_applied(|_ctx| println!("Subscripted to the person table"))
+        .on_error(|_ctx, e| eprintln!("There was an error when subscring to the person table: {e}"))
+        .subscribe(["SELECT * FROM person"]);
 
     // Register a callback for when rows are inserted into the person table
-    Person::on_insert(|_ctx, person| {
+    conn.db().person().on_insert(|_ctx, person| {
         println!("New person: {}", person.name);
     });
 
-    // Run the connection on the current thread
-    // This will block and handle all database events
-    conn.run();
+    println!("Press any key to exit...");
+
+    let _ = io::stdin().read(&mut [0u8]).unwrap();
 }

crates/cli/templates/basic-rust/server/src/lib.rs

@@ -1,6 +1,6 @@
 use spacetimedb::{ReducerContext, Table};
 
-#[spacetimedb::table(name = person)]
+#[spacetimedb::table(name = person, public)]
 pub struct Person {
     name: String,
 }

crates/codegen/src/csharp.rs

@@ -7,8 +7,8 @@ use std::ops::Deref;
 use super::code_indenter::CodeIndenter;
 use super::Lang;
 use crate::util::{
-    collect_case, is_reducer_invokable, iter_indexes, iter_reducers, iter_tables, print_auto_generated_file_comment,
-    print_auto_generated_version_comment, type_ref_name,
+    collect_case, is_reducer_invokable, iter_indexes, iter_reducers, iter_table_names_and_types,
+    print_auto_generated_file_comment, print_auto_generated_version_comment, type_ref_name,
 };
 use crate::{indent_scope, OutputFile};
 use convert_case::{Case, Casing};
@@ -745,11 +745,11 @@ impl Lang for Csharp<'_> {
         indented_block(&mut output, |output| {
             writeln!(output, "public RemoteTables(DbConnection conn)");
             indented_block(output, |output| {
-                for table in iter_tables(module) {
+                for (table_name, _) in iter_table_names_and_types(module) {
                     writeln!(
                         output,
                         "AddTable({} = new(conn));",
-                        table.name.deref().to_case(Case::Pascal)
+                        table_name.deref().to_case(Case::Pascal)
                     );
                 }
             });

crates/codegen/src/rust.rs

@@ -2,8 +2,8 @@ use super::code_indenter::{CodeIndenter, Indenter};
 use super::util::{collect_case, iter_reducers, print_lines, type_ref_name};
 use super::Lang;
 use crate::util::{
-    iter_procedures, iter_tables, iter_types, iter_unique_cols, print_auto_generated_file_comment,
-    print_auto_generated_version_comment,
+    iter_procedures, iter_table_names_and_types, iter_tables, iter_types, iter_unique_cols, iter_views,
+    print_auto_generated_file_comment, print_auto_generated_version_comment,
 };
 use crate::OutputFile;
 use convert_case::{Case, Casing};
@@ -930,12 +930,13 @@ fn reducer_flags_trait_name(reducer: &ReducerDef) -> String {
     format!("set_flags_for_{}", reducer_function_name(reducer))
 }
 
-/// Iterate over all of the Rust `mod`s for types, reducers and tables in the `module`.
+/// Iterate over all of the Rust `mod`s for types, reducers, views, and tables in the `module`.
 fn iter_module_names(module: &ModuleDef) -> impl Iterator<Item = String> + '_ {
     itertools::chain!(
         iter_types(module).map(|ty| type_module_name(&ty.name)),
         iter_reducers(module).map(|r| reducer_module_name(&r.name)),
         iter_tables(module).map(|tbl| table_module_name(&tbl.name)),
+        iter_views(module).map(|view| table_module_name(&view.name)),
         iter_procedures(module).map(|proc| procedure_module_name(&proc.name)),
     )
 }
@@ -954,8 +955,8 @@ fn print_module_reexports(module: &ModuleDef, out: &mut Indenter) {
         let type_name = collect_case(Case::Pascal, ty.name.name_segments());
         writeln!(out, "pub use {mod_name}::{type_name};")
     }
-    for table in iter_tables(module) {
-        let mod_name = table_module_name(&table.name);
+    for (table_name, _) in iter_table_names_and_types(module) {
+        let mod_name = table_module_name(table_name);
         // TODO: More precise reexport: we want:
         // - The trait name.
         // - The insert, delete and possibly update callback ids.
@@ -1113,12 +1114,12 @@ fn print_db_update_defn(module: &ModuleDef, out: &mut Indenter) {
     out.delimited_block(
         "pub struct DbUpdate {",
         |out| {
-            for table in iter_tables(module) {
+            for (table_name, product_type_ref) in iter_table_names_and_types(module) {
                 writeln!(
                     out,
                     "{}: __sdk::TableUpdate<{}>,",
-                    table_method_name(&table.name),
-                    type_ref_name(module, table.product_type_ref),
+                    table_method_name(table_name),
+                    type_ref_name(module, product_type_ref),
                 );
             }
         },
@@ -1137,13 +1138,13 @@ impl TryFrom<__ws::DatabaseUpdate<__ws::BsatnFormat>> for DbUpdate {
             match &table_update.table_name[..] {
 ",
         |out| {
-            for table in iter_tables(module) {
+            for (table_name, _) in iter_table_names_and_types(module) {
                 writeln!(
                     out,
                     "{:?} => db_update.{}.append({}::parse_table_update(table_update)?),",
-                    table.name.deref(),
-                    table_method_name(&table.name),
-                    table_module_name(&table.name),
+                    table_name.deref(),
+                    table_method_name(table_name),
+                    table_module_name(table_name),
                 );
             }
         },
@@ -1181,21 +1182,28 @@ impl __sdk::InModule for DbUpdate {{
                     let mut diff = AppliedDiff::default();
                 ",
                 |out| {
-                    for table in iter_tables(module) {
-                        let with_updates = table
-                            .primary_key
-                            .map(|col| {
-                                let pk_field = table.get_column(col).unwrap().name.deref().to_case(Case::Snake);
-                                format!(".with_updates_by_pk(|row| &row.{pk_field})")
-                            })
-                            .unwrap_or_default();
-
-                        let field_name = table_method_name(&table.name);
+                    for (table_name, product_type_ref, with_updates) in itertools::chain!(
+                        iter_tables(module).map(|table| {
+                            (
+                                &table.name,
+                                table.product_type_ref,
+                                table
+                                    .primary_key
+                                    .map(|col| {
+                                        let pk_field = table.get_column(col).unwrap().name.deref().to_case(Case::Snake);
+                                        format!(".with_updates_by_pk(|row| &row.{pk_field})")
+                                    })
+                                    .unwrap_or_default(),
+                            )
+                        }),
+                        iter_views(module).map(|view| (&view.name, view.product_type_ref, "".into()))
+                    ) {
+                        let field_name = table_method_name(table_name);
                         writeln!(
                             out,
                             "diff.{field_name} = cache.apply_diff_to_table::<{}>({:?}, &self.{field_name}){with_updates};",
-                            type_ref_name(module, table.product_type_ref),
-                            table.name.deref(),
+                            type_ref_name(module, product_type_ref),
+                            table_name.deref(),
                         );
                     }
                 },
@@ -1215,12 +1223,12 @@ fn print_applied_diff_defn(module: &ModuleDef, out: &mut Indenter) {
     out.delimited_block(
         "pub struct AppliedDiff<'r> {",
         |out| {
-            for table in iter_tables(module) {
+            for (table_name, product_type_ref) in iter_table_names_and_types(module) {
                 writeln!(
                     out,
                     "{}: __sdk::TableAppliedDiff<'r, {}>,",
-                    table_method_name(&table.name),
-                    type_ref_name(module, table.product_type_ref),
+                    table_method_name(table_name),
+                    type_ref_name(module, product_type_ref),
                 );
             }
             // Also write a `PhantomData` field which uses the lifetime `r`,
@@ -1248,13 +1256,13 @@ impl __sdk::InModule for AppliedDiff<'_> {{
             out.delimited_block(
                 "fn invoke_row_callbacks(&self, event: &EventContext, callbacks: &mut __sdk::DbCallbacks<RemoteModule>) {",
                 |out| {
-                    for table in iter_tables(module) {
+                    for (table_name, product_type_ref) in iter_table_names_and_types(module) {
                         writeln!(
                             out,
                             "callbacks.invoke_table_row_callbacks::<{}>({:?}, &self.{}, event);",
-                            type_ref_name(module, table.product_type_ref),
-                            table.name.deref(),
-                            table_method_name(&table.name),
+                            type_ref_name(module, product_type_ref),
+                            table_name.deref(),
+                            table_method_name(table_name),
                         );
                     }
                 },
@@ -1290,8 +1298,8 @@ type SubscriptionHandle = SubscriptionHandle;
             out.delimited_block(
                 "fn register_tables(client_cache: &mut __sdk::ClientCache<Self>) {",
                 |out| {
-                    for table in iter_tables(module) {
-                        writeln!(out, "{}::register_table(client_cache);", table_module_name(&table.name));
+                    for (table_name, _) in iter_table_names_and_types(module) {
+                        writeln!(out, "{}::register_table(client_cache);", table_module_name(table_name));
                     }
                 },
                 "}\n",

crates/codegen/src/typescript.rs

@@ -1,6 +1,6 @@
 use crate::util::{
-    is_reducer_invokable, iter_reducers, iter_tables, iter_types, iter_unique_cols,
-    print_auto_generated_version_comment,
+    is_reducer_invokable, iter_reducers, iter_table_names_and_types, iter_tables, iter_types, iter_unique_cols,
+    iter_views, print_auto_generated_version_comment,
 };
 use crate::{indent_scope, OutputFile};
 
@@ -341,10 +341,9 @@ removeOnUpdate = (cb: (ctx: EventContext, onRow: {row_type}, newRow: {row_type})
 
         writeln!(out);
         writeln!(out, "// Import and reexport all table handle types");
-        for table in iter_tables(module) {
-            let table_name = &table.name;
+        for (table_name, _) in iter_table_names_and_types(module) {
             let table_module_name = table_module_name(table_name) + ".ts";
-            let table_name_pascalcase = table.name.deref().to_case(Case::Pascal);
+            let table_name_pascalcase = table_name.deref().to_case(Case::Pascal);
             let table_handle = table_name_pascalcase.clone() + "TableHandle";
             writeln!(out, "import {{ {table_handle} }} from \"./{table_module_name}\";");
             writeln!(out, "export {{ {table_handle} }};");
@@ -366,15 +365,31 @@ removeOnUpdate = (cb: (ctx: EventContext, onRow: {row_type}, newRow: {row_type})
         out.indent(1);
         writeln!(out, "tables: {{");
         out.indent(1);
-        for table in iter_tables(module) {
-            let type_ref = table.product_type_ref;
+        for (table_name, product_type_ref, schema) in itertools::chain!(
+            iter_tables(module).map(|def| {
+                (
+                    &def.name,
+                    def.product_type_ref,
+                    TableSchema::from_module_def(module, def, (), 0.into()),
+                )
+            }),
+            iter_views(module).map(|def| {
+                (
+                    &def.name,
+                    def.product_type_ref,
+                    TableSchema::from_view_def_for_codegen(module, def),
+                )
+            })
+        ) {
+            let table_name = table_name.deref();
+            let type_ref = product_type_ref;
             let row_type = type_ref_name(module, type_ref);
-            let schema = TableSchema::from_module_def(module, table, (), 0.into())
+            let schema = schema
                 .validated()
                 .expect("Failed to generate table due to validation errors");
-            writeln!(out, "{}: {{", table.name);
+            writeln!(out, "{}: {{", table_name);
             out.indent(1);
-            writeln!(out, "tableName: \"{}\" as const,", table.name);
+            writeln!(out, "tableName: \"{}\" as const,", table_name);
             writeln!(out, "rowType: {row_type}.getTypeScriptAlgebraicType(),");
             if let Some(pk) = schema.pk() {
                 // This is left here so we can release the codegen change before releasing a new
@@ -612,13 +627,13 @@ fn print_remote_tables(module: &ModuleDef, out: &mut Indenter) {
     out.indent(1);
     writeln!(out, "constructor(private connection: __DbConnectionImpl) {{}}");
 
-    for table in iter_tables(module) {
+    for (table_name, product_type_ref) in iter_table_names_and_types(module) {
         writeln!(out);
-        let table_name = table.name.deref();
-        let table_name_pascalcase = table.name.deref().to_case(Case::Pascal);
-        let table_name_camelcase = table.name.deref().to_case(Case::Camel);
+        let table_name = table_name.deref();
+        let table_name_pascalcase = table_name.to_case(Case::Pascal);
+        let table_name_camelcase = table_name.to_case(Case::Camel);
         let table_handle = table_name_pascalcase.clone() + "TableHandle";
-        let type_ref = table.product_type_ref;
+        let type_ref = product_type_ref;
         let row_type = type_ref_name(module, type_ref);
         writeln!(out, "get {table_name_camelcase}(): {table_handle}<'{table_name}'> {{");
         out.with_indent(|out| {