feat: address comments

Author: SoulPancake

openfga_sdk/api/open_fga_api.py

@@ -86,7 +86,12 @@ async def _execute(
         headers: dict | None = None,
         options: dict | None = None,
     ) -> Any:
-        """Shared executor for all API endpoint methods."""
+        """Shared executor for all API endpoint methods.
+
+        Delegates to _execute_api_request_internal (or
+        _execute_streamed_api_request_internal when _streaming=True) so all
+        API calls share one unified code path.
+        """
         if options is None:
             options = {}
 
@@ -112,31 +117,30 @@ async def _execute(
             body=body, attributes=telemetry_attributes
         )
 
-        merged_response_types_map = {
-            **self._COMMON_ERROR_RESPONSE_TYPES,
-            **response_types_map,
-        }
+        if options.get("_streaming", False):
+            return self._execute_streamed_api_request_internal(
+                operation_name=operation_name,
+                method=method,
+                path=path,
+                body=body,
+                query_params=query_params or [],
+                headers=header_params,
+                options=options,
+                response_types_map=response_types_map,
+                telemetry_attributes=telemetry_attributes,
+            )
 
-        return await self.api_client.call_api(
-            path,
-            method,
-            {},
-            query_params or [],
-            header_params,
+        return await self._execute_api_request_internal(
+            operation_name=operation_name,
+            method=method,
+            path=path,
             body=body,
-            post_params=[],
-            files={},
-            response_types_map=merged_response_types_map,
-            auth_settings=[],
-            async_req=options.get("async_req"),
-            _return_http_data_only=True,
-            _preload_content=True,
-            _request_timeout=options.get("_request_timeout"),
-            _retry_params=options.get("_retry_params"),
-            collection_formats={},
-            _oauth2_client=self._oauth2_client,
-            _telemetry_attributes=telemetry_attributes,
-            _streaming=options.get("_streaming", False),
+            query_params=query_params or [],
+            headers=header_params,
+            options=options,
+            response_types_map=response_types_map,
+            telemetry_attributes=telemetry_attributes,
+            _skip_builder=True,
         )
 
     async def execute_api_request(
@@ -209,42 +213,90 @@ async def execute_streamed_api_request(
         :param headers: Custom headers (SDK enforces Content-Type and Accept)
         :param options: Extra options e.g. {"retry_params": RetryParams(max_retry=3)}
         """
-        from openfga_sdk.client.execute_api_request_builder import (
-            ExecuteApiRequestBuilder,
-        )
-
-        builder = ExecuteApiRequestBuilder(
+        async for chunk in self._execute_streamed_api_request_internal(
             operation_name=operation_name,
             method=method,
             path=path,
             path_params=path_params,
             body=body,
             query_params=query_params,
             headers=headers,
-        )
-        builder.validate()
+            options=options,
+        ):
+            yield chunk
 
-        resource_path = builder.build_path()
-        query_params_list = builder.build_query_params_list()
-        final_headers = builder.build_headers()
+    async def _execute_streamed_api_request_internal(
+        self,
+        *,
+        operation_name: str,
+        method: str,
+        path: str,
+        path_params: dict[str, str] | None = None,
+        body: dict[str, Any] | list[Any] | str | bytes | None = None,
+        query_params=None,
+        headers=None,
+        options: dict[str, Any] | None = None,
+        response_types_map: dict | None = None,
+        telemetry_attributes: dict | None = None,
+        _skip_builder: bool = False,
+    ) -> AsyncIterator[dict[str, Any]]:
+        """Implementation for streaming API requests.
 
-        retry_params = options.get("retry_params") if options else None
+        When _skip_builder=True, query_params must already be a list of tuples
+        and headers must already be a fully-built dict (used when called from _execute).
+        When response_types_map is provided, it is merged with _COMMON_ERROR_RESPONSE_TYPES.
+        When telemetry_attributes is provided, it is used as-is instead of building minimal defaults.
+        """
+        if _skip_builder:
+            resource_path = path
+            query_params_list = query_params if query_params is not None else []
+            final_headers = headers or {}
+        else:
+            from openfga_sdk.client.execute_api_request_builder import (
+                ExecuteApiRequestBuilder,
+            )
 
-        telemetry_attributes: dict[TelemetryAttribute, str | bool | int | float] = {
-            TelemetryAttributes.fga_client_request_method: operation_name.lower(),
-        }
-        if self.api_client.get_store_id():
-            telemetry_attributes[TelemetryAttributes.fga_client_request_store_id] = (
-                self.api_client.get_store_id()
+            builder = ExecuteApiRequestBuilder(
+                operation_name=operation_name,
+                method=method,
+                path=path,
+                path_params=path_params,
+                body=body,
+                query_params=query_params,
+                headers=headers,
             )
+            builder.validate()
+
+            resource_path = builder.build_path()
+            query_params_list = builder.build_query_params_list()
+            final_headers = builder.build_headers()
+
+        retry_params = options.get("retry_params") if options else None
+
+        if telemetry_attributes is None:
+            telemetry_attributes = {
+                TelemetryAttributes.fga_client_request_method: operation_name.lower(),
+            }
+            if self.api_client.get_store_id():
+                telemetry_attributes[
+                    TelemetryAttributes.fga_client_request_store_id
+                ] = self.api_client.get_store_id()
+
+        if response_types_map is not None:
+            merged_response_types_map = {
+                **self._COMMON_ERROR_RESPONSE_TYPES,
+                **response_types_map,
+            }
+        else:
+            merged_response_types_map = {}
 
         stream = await self.api_client.call_api(
             resource_path=resource_path,
             method=method.upper(),
             query_params=query_params_list if query_params_list else None,
             header_params=final_headers,
             body=body,
-            response_types_map={},
+            response_types_map=merged_response_types_map,
             auth_settings=[],
             _return_http_data_only=True,
             _preload_content=True,
@@ -265,42 +317,89 @@ async def _execute_api_request_internal(
         path: str,
         path_params: dict[str, str] | None = None,
         body: dict[str, Any] | list[Any] | str | bytes | None = None,
-        query_params: dict[str, str | int | list[str | int]] | None = None,
-        headers: dict[str, str] | None = None,
+        query_params=None,
+        headers=None,
         options: dict[str, Any] | None = None,
-    ) -> RawResponse:
-        """Implementation for execute_api_request."""
+        response_types_map: dict | None = None,
+        telemetry_attributes: dict | None = None,
+        _skip_builder: bool = False,
+    ) -> Any:
+        """Implementation for execute_api_request (and _execute delegation).
+
+        When _skip_builder=True, query_params must already be a list of tuples
+        and headers must already be a fully-built dict (used when called from _execute).
+        When response_types_map is provided, it is merged with _COMMON_ERROR_RESPONSE_TYPES
+        and the deserialized typed result from call_api is returned directly.
+        When telemetry_attributes is provided, it is used as-is instead of building minimal defaults.
+        """
         from openfga_sdk.client.execute_api_request_builder import (
             ExecuteApiRequestBuilder,
             ResponseParser,
         )
         from openfga_sdk.client.models.raw_response import RawResponse
 
-        builder = ExecuteApiRequestBuilder(
-            operation_name=operation_name,
-            method=method,
-            path=path,
-            path_params=path_params,
-            body=body,
-            query_params=query_params,
-            headers=headers,
-        )
-        builder.validate()
+        if _skip_builder:
+            resource_path = path
+            query_params_list = query_params if query_params is not None else []
+            final_headers = headers or {}
+        else:
+            builder = ExecuteApiRequestBuilder(
+                operation_name=operation_name,
+                method=method,
+                path=path,
+                path_params=path_params,
+                body=body,
+                query_params=query_params,
+                headers=headers,
+            )
+            builder.validate()
 
-        resource_path = builder.build_path()
-        query_params_list = builder.build_query_params_list()
-        final_headers = builder.build_headers()
+            resource_path = builder.build_path()
+            query_params_list = builder.build_query_params_list()
+            final_headers = builder.build_headers()
 
         retry_params = options.get("retry_params") if options else None
-
-        telemetry_attributes: dict[TelemetryAttribute, str | bool | int | float] = {
-            TelemetryAttributes.fga_client_request_method: operation_name.lower(),
-        }
-        if self.api_client.get_store_id():
-            telemetry_attributes[TelemetryAttributes.fga_client_request_store_id] = (
-                self.api_client.get_store_id()
+        request_timeout = options.get("_request_timeout") if options else None
+        async_req = options.get("async_req") if options else None
+
+        if telemetry_attributes is None:
+            telemetry_attributes = {
+                TelemetryAttributes.fga_client_request_method: operation_name.lower(),
+            }
+            if self.api_client.get_store_id():
+                telemetry_attributes[
+                    TelemetryAttributes.fga_client_request_store_id
+                ] = self.api_client.get_store_id()
+
+        if response_types_map is not None:
+            merged_response_types_map = {
+                **self._COMMON_ERROR_RESPONSE_TYPES,
+                **response_types_map,
+            }
+            # call_api returns a deserialized typed model when response_types_map is non-empty
+            return await self.api_client.call_api(
+                resource_path=resource_path,
+                method=method.upper(),
+                path_params={},
+                query_params=query_params_list if query_params_list else [],
+                header_params=final_headers,
+                body=body,
+                post_params=[],
+                files={},
+                response_types_map=merged_response_types_map,
+                auth_settings=[],
+                async_req=async_req,
+                _return_http_data_only=True,
+                _preload_content=True,
+                _request_timeout=request_timeout,
+                _retry_params=retry_params,
+                collection_formats={},
+                _oauth2_client=self._oauth2_client,
+                _telemetry_attributes=telemetry_attributes,
+                _streaming=False,
             )
 
+        # No response_types_map: public execute_api_request path → return RawResponse
         await self.api_client.call_api(
             resource_path=resource_path,
             method=method.upper(),