fix client codegen for views

Author: joshua-spacetime

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),
                 );
             }
         },
@@ -1198,6 +1199,15 @@ impl __sdk::InModule for DbUpdate {{
                             table.name.deref(),
                         );
                     }
+                    for view in iter_views(module) {
+                        let field_name = table_method_name(&view.name);
+                        writeln!(
+                            out,
+                            "diff.{field_name} = cache.apply_diff_to_table::<{}>({:?}, &self.{field_name});",
+                            type_ref_name(module, view.product_type_ref),
+                            view.name.deref(),
+                        );
+                    }
                 },
                 "
                     diff
@@ -1215,12 +1225,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 +1258,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 +1300,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,5 +1,5 @@
 use crate::util::{
-    is_reducer_invokable, iter_constraints, iter_indexes, iter_reducers, iter_table_and_view_names, iter_tables,
+    is_reducer_invokable, iter_constraints, iter_indexes, iter_reducers, iter_table_names_and_types, iter_tables,
     iter_types, iter_views, print_auto_generated_version_comment,
 };
 use crate::OutputFile;
@@ -195,7 +195,7 @@ impl Lang for TypeScript {
 
         writeln!(out);
         writeln!(out, "// Import and reexport all table handle types");
-        for table_name in iter_table_and_view_names(module) {
+        for (table_name, _) in iter_table_names_and_types(module) {
             let table_module_name = table_module_name(table_name);
             let table_name_pascalcase = table_name.deref().to_case(Case::Pascal);
             // TODO: This really shouldn't be necessary. We could also have `table()` accept

crates/codegen/src/unrealcpp.rs

@@ -1,7 +1,8 @@
 //! Autogenerated Unreal‑C++ code‑gen backend for SpacetimeDB CLI
 use crate::code_indenter::CodeIndenter;
 use crate::util::{
-    collect_case, fmt_fn, iter_tables, print_auto_generated_file_comment, print_auto_generated_version_comment,
+    collect_case, fmt_fn, iter_table_names_and_types, print_auto_generated_file_comment,
+    print_auto_generated_version_comment,
 };
 use crate::util::{iter_indexes, iter_reducers};
 use crate::Lang;
@@ -683,8 +684,8 @@ impl Lang for UnrealCpp<'_> {
         writeln!(client_h);
 
         writeln!(client_h, "/** Forward declaration for tables */");
-        for table in iter_tables(module) {
-            let table_pascal = type_ref_name(module, table.product_type_ref);
+        for (_, product_type_ref) in iter_table_names_and_types(module) {
+            let table_pascal = type_ref_name(module, product_type_ref);
             writeln!(client_h, "class U{table_pascal}Table;");
         }
         writeln!(client_h, "/***/");
@@ -774,12 +775,11 @@ impl Lang for UnrealCpp<'_> {
         });
 
         // Build table includes
-        let table_includes: Vec<String> = module
-            .tables()
-            .map(|table| {
+        let table_includes: Vec<String> = iter_table_names_and_types(module)
+            .map(|(_, product_type_ref)| {
                 format!(
                     "ModuleBindings/Tables/{}Table.g.h",
-                    type_ref_name(module, table.product_type_ref)
+                    type_ref_name(module, product_type_ref)
                 )
             })
             .collect();
@@ -1856,14 +1856,14 @@ fn generate_remote_tables_class(output: &mut UnrealCppAutogen, module: &ModuleDe
     writeln!(output);
 
     // Generate table handle properties
-    for table in module.tables() {
-        let table_pascal = type_ref_name(module, table.product_type_ref);
+    for (table_name, product_type_ref) in iter_table_names_and_types(module) {
+        let table_pascal = type_ref_name(module, product_type_ref);
 
         writeln!(output, "    UPROPERTY(BlueprintReadOnly, Category=\"SpacetimeDB\")");
         writeln!(
             output,
             "    U{table_pascal}Table* {};",
-            table.name.deref().to_case(Case::Pascal)
+            table_name.deref().to_case(Case::Pascal)
         );
         writeln!(output);
     }
@@ -2357,16 +2357,16 @@ fn generate_client_implementation(output: &mut UnrealCppAutogen, module: &Module
     writeln!(output, "\tReducers->SetCallReducerFlags = SetReducerFlags;");
     writeln!(output, "\tReducers->Conn = this;");
     writeln!(output);
-    for table in module.tables() {
-        let table_pascal = type_ref_name(module, table.product_type_ref);
-        let table_name = table.name.deref();
+    for (table_name, product_type_ref) in iter_table_names_and_types(module) {
+        let table_pascal = type_ref_name(module, product_type_ref);
+        let table_name = table_name.deref();
         writeln!(
             output,
             "\tRegisterTable<F{}Type, U{}Table, FEventContext>(TEXT(\"{}\"), Db->{});",
             table_pascal,
             table_pascal,
             table_name,
-            table.name.deref().to_case(Case::Pascal)
+            table_name.to_case(Case::Pascal)
         );
     }
     writeln!(output, "}}");
@@ -2412,23 +2412,23 @@ fn generate_client_implementation(output: &mut UnrealCppAutogen, module: &Module
     writeln!(output, "{{");
     writeln!(output);
     writeln!(output, "\t/** Creating tables */");
-    for table in module.tables() {
-        let table_pascal = type_ref_name(module, table.product_type_ref);
+    for (table_name, product_type_ref) in iter_table_names_and_types(module) {
+        let table_pascal = type_ref_name(module, product_type_ref);
         writeln!(
             output,
             "\t{} = NewObject<U{}Table>(this);",
-            table.name.deref().to_case(Case::Pascal),
+            table_name.deref().to_case(Case::Pascal),
             table_pascal
         );
     }
     writeln!(output, "\t/**/");
     writeln!(output);
     writeln!(output, "\t/** Initialization */");
-    for table in module.tables() {
+    for (table_name, _) in iter_table_names_and_types(module) {
         writeln!(
             output,
             "\t{}->PostInitialize();",
-            table.name.deref().to_case(Case::Pascal)
+            table_name.deref().to_case(Case::Pascal)
         );
     }
     writeln!(output, "\t/**/");
@@ -3095,10 +3095,8 @@ fn collect_optional_types(module: &ModuleDef) -> HashSet<String> {
     }
 
     // Collect from all tables
-    for table in module.tables() {
-        let product_type = module.typespace_for_generate()[table.product_type_ref]
-            .as_product()
-            .unwrap();
+    for (_, product_type_ref) in iter_table_names_and_types(module) {
+        let product_type = module.typespace_for_generate()[product_type_ref].as_product().unwrap();
         for (_, field_ty) in &product_type.elements {
             collect_from_type(module, field_ty, &mut optional_types);
         }

crates/codegen/src/util.rs

@@ -125,12 +125,12 @@ pub(super) fn iter_views(module: &ModuleDef) -> impl Iterator<Item = &ViewDef> {
 /// Iterate over the names of all the tables and views defined by the module, in alphabetical order.
 ///
 /// Sorting is necessary to have deterministic reproducible codegen.
-pub(super) fn iter_table_and_view_names(module: &ModuleDef) -> impl Iterator<Item = &Identifier> {
-    itertools::chain(
-        module.tables().map(|table| &table.name),
-        module.views().map(|view| &view.name),
-    )
-    .sorted()
+pub(super) fn iter_table_names_and_types(module: &ModuleDef) -> impl Iterator<Item = (&Identifier, AlgebraicTypeRef)> {
+    module
+        .tables()
+        .map(|def| (&def.name, def.product_type_ref))
+        .chain(module.views().map(|def| (&def.name, def.product_type_ref)))
+        .sorted_by_key(|(name, _)| *name)
 }
 
 pub(super) fn iter_unique_cols<'a>(

crates/codegen/tests/snapshots/codegen__codegen_csharp.snap

@@ -1011,6 +1011,7 @@ namespace SpacetimeDB
         {
             AddTable(HasSpecialStuff = new(conn));
             AddTable(LoggedOutPlayer = new(conn));
+            AddTable(MyPlayer = new(conn));
             AddTable(Person = new(conn));
             AddTable(PkMultiIdentity = new(conn));
             AddTable(Player = new(conn));

crates/codegen/tests/snapshots/codegen__codegen_rust.snap

@@ -1421,6 +1421,7 @@ pub mod test_a_table;
 pub mod test_d_table;
 pub mod test_e_table;
 pub mod test_f_table;
+pub mod my_player_table;
 pub mod return_value_procedure;
 pub mod sleep_one_second_procedure;
 
@@ -1442,6 +1443,7 @@ pub use namespace_test_c_type::NamespaceTestC;
 pub use namespace_test_f_type::NamespaceTestF;
 pub use has_special_stuff_table::*;
 pub use logged_out_player_table::*;
+pub use my_player_table::*;
 pub use person_table::*;
 pub use pk_multi_identity_table::*;
 pub use player_table::*;
@@ -1568,6 +1570,7 @@ fn try_from(value: __ws::ReducerCallInfo<__ws::BsatnFormat>) -> __sdk::Result<Se
 pub struct DbUpdate {
         has_special_stuff: __sdk::TableUpdate<HasSpecialStuff>,
     logged_out_player: __sdk::TableUpdate<Player>,
+    my_player: __sdk::TableUpdate<Player>,
     person: __sdk::TableUpdate<Person>,
     pk_multi_identity: __sdk::TableUpdate<PkMultiIdentity>,
     player: __sdk::TableUpdate<Player>,
@@ -1590,6 +1593,7 @@ impl TryFrom<__ws::DatabaseUpdate<__ws::BsatnFormat>> for DbUpdate {
 
         "has_special_stuff" => db_update.has_special_stuff.append(has_special_stuff_table::parse_table_update(table_update)?),
     "logged_out_player" => db_update.logged_out_player.append(logged_out_player_table::parse_table_update(table_update)?),
+    "my_player" => db_update.my_player.append(my_player_table::parse_table_update(table_update)?),
     "person" => db_update.person.append(person_table::parse_table_update(table_update)?),
     "pk_multi_identity" => db_update.pk_multi_identity.append(pk_multi_identity_table::parse_table_update(table_update)?),
     "player" => db_update.player.append(player_table::parse_table_update(table_update)?),
@@ -1634,6 +1638,7 @@ impl __sdk::DbUpdate for DbUpdate {
         diff.test_d = cache.apply_diff_to_table::<TestD>("test_d", &self.test_d);
         diff.test_e = cache.apply_diff_to_table::<TestE>("test_e", &self.test_e).with_updates_by_pk(|row| &row.id);
         diff.test_f = cache.apply_diff_to_table::<TestFoobar>("test_f", &self.test_f);
+        diff.my_player = cache.apply_diff_to_table::<Player>("my_player", &self.my_player);
 
                     diff
                 }
@@ -1645,6 +1650,7 @@ impl __sdk::DbUpdate for DbUpdate {
 pub struct AppliedDiff<'r> {
         has_special_stuff: __sdk::TableAppliedDiff<'r, HasSpecialStuff>,
     logged_out_player: __sdk::TableAppliedDiff<'r, Player>,
+    my_player: __sdk::TableAppliedDiff<'r, Player>,
     person: __sdk::TableAppliedDiff<'r, Person>,
     pk_multi_identity: __sdk::TableAppliedDiff<'r, PkMultiIdentity>,
     player: __sdk::TableAppliedDiff<'r, Player>,
@@ -1667,6 +1673,7 @@ impl<'r> __sdk::AppliedDiff<'r> for AppliedDiff<'r> {
     fn invoke_row_callbacks(&self, event: &EventContext, callbacks: &mut __sdk::DbCallbacks<RemoteModule>) {
                 callbacks.invoke_table_row_callbacks::<HasSpecialStuff>("has_special_stuff", &self.has_special_stuff, event);
         callbacks.invoke_table_row_callbacks::<Player>("logged_out_player", &self.logged_out_player, event);
+        callbacks.invoke_table_row_callbacks::<Player>("my_player", &self.my_player, event);
         callbacks.invoke_table_row_callbacks::<Person>("person", &self.person, event);
         callbacks.invoke_table_row_callbacks::<PkMultiIdentity>("pk_multi_identity", &self.pk_multi_identity, event);
         callbacks.invoke_table_row_callbacks::<Player>("player", &self.player, event);
@@ -2395,6 +2402,7 @@ impl __sdk::SpacetimeModule for RemoteModule {
 fn register_tables(client_cache: &mut __sdk::ClientCache<Self>) {
                 has_special_stuff_table::register_table(client_cache);
         logged_out_player_table::register_table(client_cache);
+        my_player_table::register_table(client_cache);
         person_table::register_table(client_cache);
         pk_multi_identity_table::register_table(client_cache);
         player_table::register_table(client_cache);