[TypeScript] Remove entries from filtering (#31)

* [TypeScript] Remove entries from filtering

In the TypeScript SDK we keep "entries" - an algebraic value of records.
I added them because they were also used in the C# SDK, but we don't
really need them. This commit changes generated filtering functions so
that they compare actual instances instead of product values.

Author: drogus

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

@@ -1012,8 +1012,9 @@ fn autogen_typescript_access_funcs_for_struct(
         let field_name = field.name.as_ref().expect("autogen'd tuples should have field names");
         let field_type = &field.algebraic_type;
         let typescript_field_name_pascal = field_name.replace("r#", "").to_case(Case::Pascal);
+        let typescript_field_name_camel = field_name.replace("r#", "").to_case(Case::Camel);
 
-        let (field_type, typescript_field_type) = match field_type {
+        let typescript_field_type = match field_type {
             AlgebraicType::Product(_) | AlgebraicType::Ref(_) => {
                 // TODO: We don't allow filtering on tuples right now, its possible we may consider it for the future.
                 continue;
@@ -1023,11 +1024,11 @@ fn autogen_typescript_access_funcs_for_struct(
                 continue;
             }
             AlgebraicType::Builtin(b) => match maybe_primitive(b) {
-                MaybePrimitive::Primitive(ty) => (typescript_as_type(b).to_string(), ty),
+                MaybePrimitive::Primitive(ty) => ty,
                 MaybePrimitive::Array(ArrayType { elem_ty }) => {
                     if let Some(BuiltinType::U8) = elem_ty.as_builtin() {
                         // Do allow filtering for byte arrays
-                        ("Bytes".into(), "Uint8Array")
+                        "Uint8Array"
                     } else {
                         // TODO: We don't allow filtering based on an array type, but we might want other functionality here in the future.
                         continue;
@@ -1042,15 +1043,15 @@ fn autogen_typescript_access_funcs_for_struct(
 
         let filter_return_type = fmt_fn(|f| {
             if is_unique {
-                f.write_str(struct_name_pascal_case)
+                write!(f, "{struct_name_pascal_case} | null")
             } else {
                 write!(f, "{struct_name_pascal_case}[]")
             }
         });
 
         writeln!(
             output,
-            "public static filterBy{typescript_field_name_pascal}(value: {typescript_field_type}): {filter_return_type} | null"
+            "public static filterBy{typescript_field_name_pascal}(value: {typescript_field_type}): {filter_return_type}"
         )
         .unwrap();
 
@@ -1062,53 +1063,51 @@ fn autogen_typescript_access_funcs_for_struct(
             }
             writeln!(
                 output,
-                "for(let entry of __SPACETIMEDB__.clientDB.getTable(\"{table_name}\").getEntries())"
+                "for(let instance of __SPACETIMEDB__.clientDB.getTable(\"{table_name}\").getInstances())"
             )
             .unwrap();
             writeln!(output, "{{").unwrap();
             {
                 indent_scope!(output);
-                writeln!(output, "var productValue = entry.asProductValue();").unwrap();
-                writeln!(
-                    output,
-                    "let compareValue = productValue.elements[{col_i}].as{field_type}() as {typescript_field_type};"
-                )
-                .unwrap();
                 if typescript_field_type == "Uint8Array" {
                     writeln!(
                         output,
                         "let byteArrayCompare = function (a1: Uint8Array, a2: Uint8Array)
 {{
-    if (a1.length != a2.length)
+    if (a1.length !== a2.length)
         return false;
 
     for (let i=0; i<a1.length; i++)
-        if (a1[i]!=a2[i])
+        if (a1[i]!==a2[i])
             return false;
 
     return true;
 }}"
                     )
                     .unwrap();
                     writeln!(output).unwrap();
-                    writeln!(output, "if (byteArrayCompare(compareValue, value)) {{").unwrap();
+                    writeln!(
+                        output,
+                        "if (byteArrayCompare(instance.{typescript_field_name_camel}, value)) {{"
+                    )
+                    .unwrap();
                     {
                         indent_scope!(output);
                         if is_unique {
-                            writeln!(output, "return {struct_name_pascal_case}.fromValue(entry);").unwrap();
+                            writeln!(output, "return instance;").unwrap();
                         } else {
-                            writeln!(output, "result.push({struct_name_pascal_case}.fromValue(entry));").unwrap();
+                            writeln!(output, "result.push(instance);").unwrap();
                         }
                     }
                     writeln!(output, "}}").unwrap();
                 } else {
-                    writeln!(output, "if (compareValue == value) {{").unwrap();
+                    writeln!(output, "if (instance.{typescript_field_name_camel} === value) {{").unwrap();
                     {
                         indent_scope!(output);
                         if is_unique {
-                            writeln!(output, "return {struct_name_pascal_case}.fromValue(entry);").unwrap();
+                            writeln!(output, "return instance;").unwrap();
                         } else {
-                            writeln!(output, "result.push({struct_name_pascal_case}.fromValue(entry));").unwrap();
+                            writeln!(output, "result.push(instance);").unwrap();
                         }
                     }
                     writeln!(output, "}}").unwrap();