implement ids-no-names in c# sdk codegen

Author: Centril

crates/cli/src/subcommands/generate/csharp.rs

@@ -5,6 +5,7 @@ use std::fmt::{self, Write};
 use std::ops::Deref;
 
 use convert_case::{Case, Casing};
+use itertools::Itertools;
 use spacetimedb_lib::sats::{AlgebraicType, AlgebraicTypeRef, ArrayType, ProductType, SumType};
 use spacetimedb_lib::ReducerDef;
 use spacetimedb_primitives::ColList;
@@ -505,7 +506,7 @@ fn autogen_csharp_access_funcs_for_struct(
     }
 }
 
-pub fn autogen_csharp_reducer(ctx: &GenCtx, reducer: &ReducerDef, namespace: &str) -> String {
+pub fn autogen_csharp_reducer(ctx: &GenCtx, reducer_idx: usize, reducer: &ReducerDef, namespace: &str) -> String {
     let func_name = &*reducer.name;
     let func_name_pascal_case = func_name.to_case(Case::Pascal);
 
@@ -515,7 +516,7 @@ pub fn autogen_csharp_reducer(ctx: &GenCtx, reducer: &ReducerDef, namespace: &st
     writeln!(output, "[SpacetimeDB.Type]");
     writeln!(output, "public partial class {func_name_pascal_case} : IReducerArgs");
     indented_block(&mut output, |output| {
-        writeln!(output, "string IReducerArgs.ReducerName => \"{func_name}\";");
+        writeln!(output, "uint IReducerArgs.ReducerIndex => {reducer_idx};");
         if !reducer.args.is_empty() {
             writeln!(output);
         }
@@ -542,13 +543,17 @@ pub fn autogen_csharp_reducer(ctx: &GenCtx, reducer: &ReducerDef, namespace: &st
 pub fn autogen_csharp_globals(ctx: &GenCtx, items: &[GenItem], namespace: &str) -> Vec<(String, String)> {
     let mut results = Vec::new();
 
-    let tables = items.iter().filter_map(|i| {
-        if let GenItem::Table(table) = i {
-            Some(table)
-        } else {
-            None
-        }
-    });
+    let tables: Vec<_> = items
+        .iter()
+        .filter_map(|i| {
+            if let GenItem::Table(table) = i {
+                Some(table)
+            } else {
+                None
+            }
+        })
+        .sorted_by_key(|t| &t.schema.table_name)
+        .collect();
 
     let reducers: Vec<&ReducerDef> = items
         .iter()
@@ -559,6 +564,7 @@ pub fn autogen_csharp_globals(ctx: &GenCtx, items: &[GenItem], namespace: &str)
                 None
             }
         })
+        .sorted_by_key(|i| &i.name)
         .collect();
     let reducer_names: Vec<String> = reducers
         .iter()
@@ -569,7 +575,7 @@ pub fn autogen_csharp_globals(ctx: &GenCtx, items: &[GenItem], namespace: &str)
 
     writeln!(output, "public sealed class RemoteTables");
     indented_block(&mut output, |output| {
-        for table in tables {
+        for &table in &tables {
             let schema = &table.schema;
             let name = &schema.table_name;
             let csharp_name = name.as_ref().to_case(Case::Pascal);
@@ -766,8 +772,6 @@ pub fn autogen_csharp_globals(ctx: &GenCtx, items: &[GenItem], namespace: &str)
             writeln!(output, "{reducer_name} {reducer_name},");
         }
         writeln!(output, "Unit StdbNone,");
-        writeln!(output, "Unit StdbIdentityConnected,");
-        writeln!(output, "Unit StdbIdentityDisconnected");
     }
     writeln!(output, ")>;");
 
@@ -787,43 +791,33 @@ pub fn autogen_csharp_globals(ctx: &GenCtx, items: &[GenItem], namespace: &str)
             writeln!(output, "Reducers = new(this, this.SetReducerFlags);");
             writeln!(output);
 
-            for item in items {
-                if let GenItem::Table(table) = item {
-                    writeln!(
-                        output,
-                        "clientDB.AddTable<{table_type}>(\"{table_name}\", Db.{csharp_table_name});",
-                        table_type = csharp_typename(ctx, table.data),
-                        table_name = table.schema.table_name,
-                        csharp_table_name = table.schema.table_name.as_ref().to_case(Case::Pascal)
-                    );
-                }
+            for (table_idx, &table) in tables.iter().enumerate() {
+                writeln!(
+                    output,
+                    "clientDB.AddTable<{table_type}>({table_idx}, Db.{csharp_table_name});",
+                    table_type = csharp_typename(ctx, table.data),
+                    csharp_table_name = table.schema.table_name.as_ref().to_case(Case::Pascal)
+                );
             }
         });
         writeln!(output);
 
-        writeln!(output, "protected override Reducer ToReducer(TransactionUpdate update)");
+        writeln!(
+            output,
+            "protected override Reducer ToReducer(uint reducerIdx, TransactionUpdate update)"
+        );
         indented_block(output, |output| {
             writeln!(output, "var encodedArgs = update.ReducerCall.Args;");
-            writeln!(output, "return update.ReducerCall.ReducerName switch {{");
+            writeln!(output, "return reducerIdx switch {{");
             {
                 indent_scope!(output);
-                for (reducer, reducer_name) in std::iter::zip(&reducers, &reducer_names) {
-                    let reducer_str_name = &reducer.name;
+                for (reducer_idx, reducer_name) in reducer_names.iter().enumerate() {
                     writeln!(
                         output,
-                        "\"{reducer_str_name}\" => new Reducer.{reducer_name}(BSATNHelpers.Decode<{reducer_name}>(encodedArgs)),"
+                        "{reducer_idx} => new Reducer.{reducer_name}(BSATNHelpers.Decode<{reducer_name}>(encodedArgs)),"
                     );
                 }
-                writeln!(output, "\"<none>\" => new Reducer.StdbNone(default),");
-                writeln!(
-                    output,
-                    "\"__identity_connected__\" => new Reducer.StdbIdentityConnected(default),"
-                );
-                writeln!(
-                    output,
-                    "\"__identity_disconnected__\" => new Reducer.StdbIdentityDisconnected(default),"
-                );
-                writeln!(output, "\"\" => new Reducer.StdbNone(default),"); //Transaction from CLI command
+                writeln!(output, "4294967295 => new Reducer.StdbNone(default),");
                 writeln!(
                     output,
                     r#"var reducer => throw new ArgumentOutOfRangeException("Reducer", $"Unknown reducer {{reducer}}")"#
@@ -855,9 +849,7 @@ pub fn autogen_csharp_globals(ctx: &GenCtx, items: &[GenItem], namespace: &str)
                         "Reducer.{reducer_name}(var args) => Reducers.Invoke{reducer_name}(eventContext, args),"
                     );
                 }
-                writeln!(output, "Reducer.StdbNone or");
-                writeln!(output, "Reducer.StdbIdentityConnected or");
-                writeln!(output, "Reducer.StdbIdentityDisconnected => true,");
+                writeln!(output, "Reducer.StdbNone => true,");
                 writeln!(
                     output,
                     r#"_ => throw new ArgumentOutOfRangeException("Reducer", $"Unknown reducer {{reducer}}")"#

crates/cli/src/subcommands/generate/mod.rs

@@ -267,15 +267,14 @@ pub fn generate(module: RawModuleDef, lang: Language, namespace: &str) -> anyhow
             let items = itertools::chain!(
                 types,
                 tables.into_iter().map(GenItem::Table),
-                reducers
-                    .filter(|r| !(r.name.starts_with("__") && r.name.ends_with("__")))
-                    .map(GenItem::Reducer),
+                reducers.map(GenItem::Reducer),
             );
 
             let items: Vec<GenItem> = items.collect();
+            let reducer_idx = &mut 0;
             let mut files: Vec<(String, String)> = items
                 .iter()
-                .filter_map(|item| item.generate(&ctx, lang, namespace))
+                .filter_map(|item| item.generate(&ctx, reducer_idx, lang, namespace))
                 .collect();
             files.extend(generate_globals(&ctx, lang, namespace, &items));
             files
@@ -340,15 +339,21 @@ fn generate_globals(ctx: &GenCtx, lang: Language, namespace: &str, items: &[GenI
 }
 
 impl GenItem {
-    fn generate(&self, ctx: &GenCtx, lang: Language, namespace: &str) -> Option<(String, String)> {
+    fn generate(
+        &self,
+        ctx: &GenCtx,
+        reducer_idx: &mut usize,
+        lang: Language,
+        namespace: &str,
+    ) -> Option<(String, String)> {
         match lang {
-            Language::Csharp => self.generate_csharp(ctx, namespace),
+            Language::Csharp => self.generate_csharp(ctx, reducer_idx, namespace),
             Language::TypeScript => unreachable!(),
             Language::Rust => unreachable!(),
         }
     }
 
-    fn generate_csharp(&self, ctx: &GenCtx, namespace: &str) -> Option<(String, String)> {
+    fn generate_csharp(&self, ctx: &GenCtx, reducer_idx: &mut usize, namespace: &str) -> Option<(String, String)> {
         match self {
             GenItem::Table(table) => {
                 let code = csharp::autogen_csharp_table(ctx, table, namespace);
@@ -367,7 +372,8 @@ impl GenItem {
                 _ => todo!(),
             },
             GenItem::Reducer(reducer) => {
-                let code = csharp::autogen_csharp_reducer(ctx, reducer, namespace);
+                let code = csharp::autogen_csharp_reducer(ctx, *reducer_idx, reducer, namespace);
+                *reducer_idx += 1;
                 let pascalcase = reducer.name.deref().to_case(Case::Pascal);
                 Some((pascalcase + "Reducer.cs", code))
             }