wip

Author: airportyh

src/replit_river/codegen/client.py

@@ -761,6 +761,7 @@ def generate_individual_service(
     schema_name: str,
     schema: RiverService,
     input_base_class: Literal["TypedDict"] | Literal["BaseModel"],
+
 ) -> Tuple[ModuleName, ClassName, dict[RenderedPath, FileContents]]:
     serdes: list[Tuple[list[TypeName], list[ModuleName], list[FileContents]]] = []
     class_name = ClassName(f"{schema_name.title()}Service")
@@ -812,13 +813,22 @@ def __init__(self, client: river.Client[Any]):
             module_names,
             permit_unknown_members=True,
         )
+        output_type_name = extract_inner_type(output_type)
         serdes.append(
             (
-                [extract_inner_type(output_type), *encoder_names],
+                [output_type_name, *encoder_names],
                 module_info,
                 output_chunks,
             )
         )
+        output_type_type_adapter_name = TypeName(f"{output_type_name.value}TypeAdapter")
+        serdes.append(
+            (
+                [output_type_type_adapter_name],
+                module_info,
+                [f"{output_type_type_adapter_name.value} = TypeAdapter({render_type_expr(output_type)})  # type: ignore"],
+            )
+        )
         if procedure.errors:
             error_type, module_info, errors_chunks, encoder_names = encode_type(
                 procedure.errors,
@@ -828,27 +838,41 @@ def __init__(self, client: river.Client[Any]):
                 permit_unknown_members=True,
             )
             if isinstance(error_type, NoneTypeExpr):
-                error_type = TypeName("RiverError")
+                error_type_name = TypeName("RiverError")
+                error_type = error_type_name
             else:
+                error_type_name = extract_inner_type(error_type)
                 serdes.append(
-                    ([extract_inner_type(error_type)], module_info, errors_chunks)
+                    ([error_type_name], module_info, errors_chunks)
+                )
+            
+            error_type_type_adapter_name = TypeName(f"{error_type.value}TypeAdapter")
+            serdes.append(
+                (
+                    [error_type_type_adapter_name],
+                    module_info,
+                    [f"{error_type_type_adapter_name.value} = TypeAdapter({render_type_expr(error_type)})  # type: ignore"],
                 )
+            )
         else:
-            error_type = TypeName("RiverError")
-        output_or_error_type = UnionTypeExpr([output_type, error_type])
+            error_type_name = TypeName("RiverError")
+
+        
+        output_or_error_type = UnionTypeExpr([output_type, error_type_name])
+    
 
         # NB: These strings must be indented to at least the same level of
         #     the function strings in the branches below, otherwise `dedent`
         #     will pick our indentation level for normalization, which will
         #     break the "def" indentation presuppositions.
         parse_output_method = f"""\
-                            lambda x: TypeAdapter({render_type_expr(output_type)})
+                            lambda x: {output_type_type_adapter_name.value}
                                 .validate_python(
                                     x # type: ignore[arg-type]
                                 )
                             """
         parse_error_method = f"""\
-                            lambda x: TypeAdapter({render_type_expr(error_type)})
+                            lambda x: {error_type_type_adapter_name.value}
                                 .validate_python(
                                     x # type: ignore[arg-type]
                                 )
@@ -871,8 +895,17 @@ def __init__(self, client: river.Client[Any]):
                 else:
                     render_init_method = f"encode_{render_literal_type(init_type)}"
             else:
+                init_type_name = extract_inner_type(init_type)
+                init_type_type_adapter_name = TypeName(f"{init_type_name.value}TypeAdapter")
+                serdes.append(
+                    (
+                        [init_type_type_adapter_name],
+                        module_info,
+                        [f"{init_type_type_adapter_name.value} = TypeAdapter({render_type_expr(init_type)})  # type: ignore"]
+                    )
+                )
                 render_init_method = f"""\
-                                lambda x: TypeAdapter({render_type_expr(init_type)})
+                                lambda x: {init_type_type_adapter_name.name})
                                   .validate_python
                 """
 
@@ -898,8 +931,17 @@ def __init__(self, client: river.Client[Any]):
             else:
                 render_input_method = f"encode_{render_literal_type(input_type)}"
         else:
+            input_type_name = extract_inner_type(input_type)
+            input_type_type_adapter_name = TypeName(f"{input_type_name.value}TypeAdapter")
+            serdes.append(
+                (
+                    [input_type_type_adapter_name],
+                    module_info,
+                    [f"{input_type_type_adapter_name.value} = TypeAdapter({render_type_expr(input_type)})  # type: ignore"]
+                )
+            )
             render_input_method = f"""\
-                            lambda x: TypeAdapter({render_type_expr(input_type)})
+                            lambda x: {input_type_type_adapter_name.value}
                               .dump_python(
                                 x, # type: ignore[arg-type]
                                 by_alias=True,