added fix for nasty bug in Fast_API__Route__Extractor where the 'BaseClass' wrappers where being used in the data extracted (instead of the correct types)

Author: DinisCruz

…api/routes/Type_Safe__Route__Analyzer.py …/type_safe/Type_Safe__Route__Analyzer.pyosbot_fast_api/api/routes/Type_Safe__Route__Analyzer.py renamed to osbot_fast_api/api/routes/type_safe/Type_Safe__Route__Analyzer.py osbot_fast_api/api/routes/Type_Safe__Route__Analyzer.py renamed to osbot_fast_api/api/routes/type_safe/Type_Safe__Route__Analyzer.py

@@ -31,6 +31,12 @@ def create_wrapper(self, function  : Callable                 ,         # Origin
         if hasattr(function, '__route_path__'):                                         # Also preserve route_path decorator if it exists
             wrapper_function.__route_path__ = function.__route_path__
 
+        if signature.type_safe_conversions or signature.primitive_conversions:
+            wrapper_function.__original_param_types__ = {}
+            for param_info in signature.parameters:
+                wrapper_function.__original_param_types__[str(param_info.name)] = param_info.param_type
+
+
         return wrapper_function
 
     @type_safe

…pi/routes/Type_Safe__Route__Converter.py …type_safe/Type_Safe__Route__Converter.pyosbot_fast_api/api/routes/Type_Safe__Route__Converter.py renamed to osbot_fast_api/api/routes/type_safe/Type_Safe__Route__Converter.py osbot_fast_api/api/routes/Type_Safe__Route__Converter.py renamed to osbot_fast_api/api/routes/type_safe/Type_Safe__Route__Converter.py

@@ -178,10 +178,15 @@ def extract__query_params(self, route: APIRoute):
     @type_safe
     def extract__body_params(self, route: APIRoute):
         body_params = []
+        original_types = getattr(route.endpoint, '__original_param_types__', {})                                        # todo: find a better way to communicate these mappings
+
         for param in route.dependant.body_params:
-            body_params.append(Schema__Endpoint__Param(name        = param.name                   ,
-                                                       param_type  = param.type_                  ,
-                                                       required    = param.required               ,
+
+            param_type = original_types.get(param.name, param.type_)                                                   # Use original type if available, otherwise fall back to current behavior
+
+            body_params.append(Schema__Endpoint__Param(name        = param.name,
+                                                       param_type  = param_type,                                       # Now the original Type_Safe class!
+                                                       required    = param.required,
                                                        description = param.field_info.description))
         return body_params
 

…routes/Type_Safe__Route__Registration.py …e_safe/Type_Safe__Route__Registration.pyosbot_fast_api/api/routes/Type_Safe__Route__Registration.py renamed to osbot_fast_api/api/routes/type_safe/Type_Safe__Route__Registration.py osbot_fast_api/api/routes/Type_Safe__Route__Registration.py renamed to osbot_fast_api/api/routes/type_safe/Type_Safe__Route__Registration.py

@@ -0,0 +1,71 @@
+from unittest                                                       import TestCase
+from fastapi                                                        import FastAPI
+from starlette.testclient                                           import TestClient
+from osbot_fast_api.client.Fast_API__Route__Extractor               import Fast_API__Route__Extractor
+from osbot_utils.type_safe.Type_Safe                                import Type_Safe
+from osbot_utils.type_safe.primitives.domains.identifiers.Safe_Id   import Safe_Id
+from osbot_fast_api.api.routes.Type_Safe__Route__Registration       import Type_Safe__Route__Registration
+
+
+class Schema__Integration_User(Type_Safe):                           # Test schema for integration
+    user_id : Safe_Id
+    name    : str
+    age     : int = 0
+
+
+class test_Fast_API__Type_Safe__routes_support(TestCase):
+
+    @classmethod
+    def setUpClass(cls):                                              # ONE-TIME setup for integration tests
+        cls.app          = FastAPI()
+        cls.registration = Type_Safe__Route__Registration()
+        cls.client       = None                                       # Will be created after routes registered
+
+    def test__full_cycle__original_types_preserved(self):            # Test complete cycle: register -> extract -> serialize -> deserialize
+        # Step 1: Register route with Type_Safe parameter
+        def create_user(user: Schema__Integration_User) -> Schema__Integration_User:
+            return user
+
+        self.registration.register_route(self.app.router, create_user, ['POST'])
+
+        # Step 2: Make actual request through TestClient
+        if self.client is None:
+            self.client = TestClient(self.app)
+
+        response = self.client.post('/create-user', json= { 'user_id': 'USER-123' ,
+                                                            'name'   : 'Test User',
+                                                            'age'    : 25         })
+
+        # Step 3: Verify response works correctly
+        assert response.status_code == 200
+        result = response.json()
+        assert result['user_id'] == 'USER-123'                        # Type_Safe handled conversion
+        assert result['name'   ] == 'Test User'
+        assert result['age'    ]  == 25
+
+        # Step 4: Extract routes and verify types
+        extractor  = Fast_API__Route__Extractor(app=self.app, include_default=False)
+        collection = extractor.extract_routes()
+
+        # Find our route
+        our_route = None                                                            # todo: we should have a helper method to provide this
+        for route in collection.routes:                                             #       need to find a particular route
+            if route.method_name == 'create_user':
+                our_route = route
+                break
+
+        assert our_route is not None
+
+        # Step 5: CRITICAL - Verify original types preserved throughout
+        assert len(our_route.body_params) == 1
+        assert our_route.body_params[0].param_type is Schema__Integration_User  # Original class
+        assert our_route.return_type is Schema__Integration_User                # Original class
+
+        # Step 6: Serialize and deserialize
+        json_data = collection.json()
+        restored  = collection.__class__.from_json(json_data)
+
+        # Step 7: Verify round-trip preserved everything
+        assert collection.obj() == restored.obj()
+
+    # todo: add more edge cases tests