[TS] Fix access before initialization in codegen (#4709)

# Description of Changes

Fixes #4584. Now we check, fully recursively, whether compound
`AlgebraicTypeUse`s contain a ref.

# Expected complexity level and risk

1

# Testing

- [x] Added a test to ensure correct codegen

---------

Co-authored-by: Zeke Foppa <196249+bfops@users.noreply.github.com>

Author: coolreader18

crates/codegen/src/typescript.rs

@@ -733,6 +733,16 @@ fn write_object_type_builder_fields(
     Ok(())
 }
 
+/// Returns whether `ty` recursively contains an `AlgebraicTypeUse::Ref`
+fn type_contains_ref(ty: &AlgebraicTypeUse) -> bool {
+    match ty {
+        AlgebraicTypeUse::Ref(_) => true,
+        AlgebraicTypeUse::Option(inner) | AlgebraicTypeUse::Array(inner) => type_contains_ref(inner),
+        AlgebraicTypeUse::Result { ok_ty, err_ty } => type_contains_ref(ok_ty) || type_contains_ref(err_ty),
+        _ => false,
+    }
+}
+
 fn write_type_builder_field(
     module: &ModuleDef,
     out: &mut Indenter,
@@ -741,17 +751,8 @@ fn write_type_builder_field(
     ty: &AlgebraicTypeUse,
     is_primary_key: bool,
 ) -> fmt::Result {
-    // Do we need a getter? (Option/Array only if their inner is a Ref)
-    let needs_getter = match ty {
-        AlgebraicTypeUse::Ref(_) => true,
-        AlgebraicTypeUse::Option(inner) | AlgebraicTypeUse::Array(inner) => {
-            matches!(inner.as_ref(), AlgebraicTypeUse::Ref(_))
-        }
-        AlgebraicTypeUse::Result { ok_ty, err_ty } => {
-            matches!(ok_ty.as_ref(), AlgebraicTypeUse::Ref(_)) || matches!(err_ty.as_ref(), AlgebraicTypeUse::Ref(_))
-        }
-        _ => false,
-    };
+    // If the type contains a ref, we need to use a getter to prevent access-before-initialization.
+    let needs_getter = type_contains_ref(ty);
 
     if needs_getter {
         writeln!(out, "get {name}() {{");

crates/codegen/tests/snapshots/codegen__codegen_csharp.snap

@@ -2036,10 +2036,12 @@ namespace SpacetimeDB
     public sealed class TestDCols
     {
         public global::SpacetimeDB.Col<TestD, NamespaceTestC> TestC { get; }
+        public global::SpacetimeDB.Col<TestD, System.Collections.Generic.List<NamespaceTestC>> TestCNested { get; }
 
         public TestDCols(string tableName)
         {
             TestC = new global::SpacetimeDB.Col<TestD, NamespaceTestC>(tableName, "test_c");
+            TestCNested = new global::SpacetimeDB.Col<TestD, System.Collections.Generic.List<NamespaceTestC>>(tableName, "test_c_nested");
         }
     }
 
@@ -2566,10 +2568,16 @@ namespace SpacetimeDB
     {
         [DataMember(Name = "test_c")]
         public NamespaceTestC? TestC;
+        [DataMember(Name = "test_c_nested")]
+        public System.Collections.Generic.List<NamespaceTestC>? TestCNested;
 
-        public TestD(NamespaceTestC? TestC)
+        public TestD(
+            NamespaceTestC? TestC,
+            System.Collections.Generic.List<NamespaceTestC>? TestCNested
+        )
         {
             this.TestC = TestC;
+            this.TestCNested = TestCNested;
         }
 
         public TestD()

crates/codegen/tests/snapshots/codegen__codegen_rust.snap

@@ -3593,6 +3593,7 @@ use super::namespace_test_c_type::NamespaceTestC;
 #[sats(crate = __lib)]
 pub struct TestD {
     pub test_c: Option::<NamespaceTestC>,
+    pub test_c_nested: Option::<Vec::<NamespaceTestC>>,
 }
 
 
@@ -3606,13 +3607,15 @@ impl __sdk::InModule for TestD {
 /// Provides typed access to columns for query building.
 pub struct TestDCols {
     pub test_c: __sdk::__query_builder::Col<TestD, Option::<NamespaceTestC>>,
+    pub test_c_nested: __sdk::__query_builder::Col<TestD, Option::<Vec::<NamespaceTestC>>>,
 }
 
 impl __sdk::__query_builder::HasCols for TestD {
     type Cols = TestDCols;
     fn cols(table_name: &'static str) -> Self::Cols {
         TestDCols {
             test_c: __sdk::__query_builder::Col::new(table_name, "test_c"),
+            test_c_nested: __sdk::__query_builder::Col::new(table_name, "test_c_nested"),
 
         }
     }

crates/codegen/tests/snapshots/codegen__codegen_typescript.snap

@@ -548,6 +548,9 @@ export default __t.row({
   get testC() {
     return __t.option(NamespaceTestC).name("test_c");
   },
+  get testCNested() {
+    return __t.option(__t.array(NamespaceTestC)).name("test_c_nested");
+  },
 });
 '''
 "test_f_table.ts" = '''
@@ -701,6 +704,9 @@ export const TestD = __t.object("TestD", {
   get testC() {
     return __t.option(NamespaceTestC);
   },
+  get testCNested() {
+    return __t.option(__t.array(NamespaceTestC));
+  },
 });
 export type TestD = __Infer<typeof TestD>;
 

modules/module-test-cs/Lib.cs

@@ -53,6 +53,7 @@ public partial struct TestD
 {
     // In Rust this was an Option<TestC>; in C# we use a nullable enum.
     public TestC? test_c;
+    public TestC[]? test_c_nested;
 }
 
 [Table(Accessor = "test_e")]

modules/module-test-ts/src/index.ts

@@ -92,6 +92,7 @@ type TestA = Infer<typeof testA>;
 // NOTE: If your Option default requires wrapping, adjust to your bindings’ Option encoding.
 const testDRow = {
   test_c: t.option(testC).default(DEFAULT_TEST_C as unknown as any),
+  test_c_nested: t.option(t.array(testC)),
 };
 type TestD = InferTypeOfRow<typeof testDRow>;
 
@@ -152,16 +153,16 @@ const spacetimedb = schema({
   person: table(
     {
       public: true,
-      indexes: [{ accessor: "age", algorithm: 'btree', columns: ['age'] }],
+      indexes: [{ accessor: 'age', algorithm: 'btree', columns: ['age'] }],
     },
     personRow
   ),
 
   // test_a with index foo on x
   testATable: table(
     {
-      name: "test_a",
-      indexes: [{ accessor: "foo", algorithm: 'btree', columns: ['x'] }],
+      name: 'test_a',
+      indexes: [{ accessor: 'foo', algorithm: 'btree', columns: ['x'] }],
     },
     testA
   ),
@@ -174,7 +175,7 @@ const spacetimedb = schema({
     {
       name: 'test_e',
       public: false,
-      indexes: [{ accessor:"name", algorithm: 'btree', columns: ['name'] }],
+      indexes: [{ accessor: 'name', algorithm: 'btree', columns: ['name'] }],
     },
     testERow
   ),
@@ -194,7 +195,11 @@ const spacetimedb = schema({
       name: 'points',
       public: false,
       indexes: [
-        { accessor: 'multi_column_index', algorithm: 'btree', columns: ['x', 'y'] },
+        {
+          accessor: 'multi_column_index',
+          algorithm: 'btree',
+          columns: ['x', 'y'],
+        },
       ],
     },
     pointsRow
@@ -207,7 +212,7 @@ const spacetimedb = schema({
   repeatingTestArg: table(
     {
       name: 'repeating_test_arg',
-      scheduled: (): any => repeatingTest
+      scheduled: (): any => repeatingTest,
     },
     repeatingTestArg
   ),

modules/module-test/src/lib.rs

@@ -67,6 +67,7 @@ const DEFAULT_TEST_C: TestC = TestC::Foo;
 pub struct TestD {
     #[default(Some(DEFAULT_TEST_C))]
     test_c: Option<TestC>,
+    test_c_nested: Option<Vec<TestC>>,
 }
 
 // uses internal apis that should not be used by user code