Return error instead of passing a log_service_error function + swap order

Author: renatillas

birdie_snapshots/http_service_with_query_parameter_mapping.accepted

@@ -189,10 +189,10 @@ pub type TemperatureServiceError {
 
 /// Auto-generated service for TemperatureService
 /// 
-/// Layer 1: Core service functions (transport-agnostic)
-/// Layer 2: HTTP adapters (works with gleam/http)
+/// Layer 1: Core service functions (transport-agnostic BitArray -> Result)
+/// Layer 2: HTTP adapters (gleam/http types, returns Result for middleware)
 /// 
-/// Error types support telemetry and logging
+/// HTTP adapters return Result(Response, ServiceError) for middleware pattern
 /// Service-level errors that can occur during request processing
 /// These can be logged for telemetry before converting to HTTP responses
 pub type ServiceError {
@@ -271,185 +271,101 @@ pub fn list_temperatures_service(
 /// HTTP adapter for GetTemperature
 /// GET /v1/temperatures/{id}
 /// Uses gleam/http types (server-agnostic)
+/// Returns Result for middleware pattern
 pub fn http_get_temperature(
   req: request.Request(BitArray),
   handler: fn(TemperatureRequest) -> Result(TemperatureResponse, TemperatureServiceError),
-  error_logger: fn(ServiceError) -> Nil,
-) -> response.Response(BitArray) {
+) -> Result(response.Response(BitArray), ServiceError) {
   // Extract request from query/path parameters
   case format_query_request_for_get_temperature(req) {
     Ok(proto_request) -> {
       // Encode the request to bytes for the service function
       let request_bytes = encode_temperature_request(proto_request)
       case get_temperature_service(request_bytes, handler) {
-        Ok(response_bytes) -> {
-          response.Response(
+        Ok(response_bytes) ->
+          Ok(response.Response(
             status: 200,
             headers: [#("content-type", "application/x-protobuf")],
             body: response_bytes,
-          )
-        }
-        Error(service_error) -> {
-          error_logger(service_error)
-          service_error_to_http_response(service_error)
-        }
+          ))
+        Error(service_error) -> Error(service_error)
       }
     }
-    Error(_) -> {
-      let err = DecodeError("Failed to parse query parameters")
-      error_logger(err)
-      service_error_to_http_response(err)
-    }
+    Error(_) -> Error(DecodeError("Failed to parse query parameters"))
   }
 }
 
 /// HTTP adapter for DeleteTemperature
 /// DELETE /v1/temperatures/{id}
 /// Uses gleam/http types (server-agnostic)
+/// Returns Result for middleware pattern
 pub fn http_delete_temperature(
   req: request.Request(BitArray),
   handler: fn(DeleteRequest) -> Result(DeleteResponse, TemperatureServiceError),
-  error_logger: fn(ServiceError) -> Nil,
-) -> response.Response(BitArray) {
+) -> Result(response.Response(BitArray), ServiceError) {
   // Extract request from query/path parameters
   case format_query_request_for_delete_temperature(req) {
     Ok(proto_request) -> {
       // Encode the request to bytes for the service function
       let request_bytes = encode_delete_request(proto_request)
       case delete_temperature_service(request_bytes, handler) {
-        Ok(response_bytes) -> {
-          response.Response(
+        Ok(response_bytes) ->
+          Ok(response.Response(
             status: 200,
             headers: [#("content-type", "application/x-protobuf")],
             body: response_bytes,
-          )
-        }
-        Error(service_error) -> {
-          error_logger(service_error)
-          service_error_to_http_response(service_error)
-        }
+          ))
+        Error(service_error) -> Error(service_error)
       }
     }
-    Error(_) -> {
-      let err = DecodeError("Failed to parse query parameters")
-      error_logger(err)
-      service_error_to_http_response(err)
-    }
+    Error(_) -> Error(DecodeError("Failed to parse query parameters"))
   }
 }
 
 /// HTTP adapter for CreateTemperature
 /// POST /v1/temperatures
 /// Uses gleam/http types (server-agnostic)
+/// Returns Result for middleware pattern
 pub fn http_create_temperature(
   req: request.Request(BitArray),
   handler: fn(TemperatureRequest) -> Result(TemperatureResponse, TemperatureServiceError),
-  error_logger: fn(ServiceError) -> Nil,
-) -> response.Response(BitArray) {
+) -> Result(response.Response(BitArray), ServiceError) {
   let request_bytes = req.body
   case create_temperature_service(request_bytes, handler) {
-    Ok(response_bytes) -> {
-      response.Response(
+    Ok(response_bytes) ->
+      Ok(response.Response(
         status: 200,
         headers: [#("content-type", "application/x-protobuf")],
         body: response_bytes,
-      )
-    }
-    Error(service_error) -> {
-      error_logger(service_error)
-      service_error_to_http_response(service_error)
-    }
+      ))
+    Error(service_error) -> Error(service_error)
   }
 }
 
 /// HTTP adapter for ListTemperatures
 /// GET /v1/temperatures
 /// Uses gleam/http types (server-agnostic)
+/// Returns Result for middleware pattern
 pub fn http_list_temperatures(
   req: request.Request(BitArray),
   handler: fn(ListRequest) -> Result(ListResponse, TemperatureServiceError),
-  error_logger: fn(ServiceError) -> Nil,
-) -> response.Response(BitArray) {
+) -> Result(response.Response(BitArray), ServiceError) {
   // Extract request from query/path parameters
   case format_query_request_for_list_temperatures(req) {
     Ok(proto_request) -> {
       // Encode the request to bytes for the service function
       let request_bytes = encode_list_request(proto_request)
       case list_temperatures_service(request_bytes, handler) {
-        Ok(response_bytes) -> {
-          response.Response(
+        Ok(response_bytes) ->
+          Ok(response.Response(
             status: 200,
             headers: [#("content-type", "application/x-protobuf")],
             body: response_bytes,
-          )
-        }
-        Error(service_error) -> {
-          error_logger(service_error)
-          service_error_to_http_response(service_error)
-        }
+          ))
+        Error(service_error) -> Error(service_error)
       }
     }
-    Error(_) -> {
-      let err = DecodeError("Failed to parse query parameters")
-      error_logger(err)
-      service_error_to_http_response(err)
-    }
-  }
-}
-/// Convert ServiceError to HTTP response
-/// This is used by the HTTP adapter layer
-fn service_error_to_http_response(error: ServiceError) -> response.Response(BitArray) {
-  case error {
-    DecodeError(msg) ->
-      response.Response(
-        status: 400,
-        headers: [#("content-type", "text/plain")],
-        body: <<"Bad Request: ", msg:utf8>>
-      )
-    HandlerError(handler_err) ->
-      handler_error_to_http_response(handler_err)
-  }
-}
-
-/// Convert handler-specific errors to HTTP responses
-fn handler_error_to_http_response(error: TemperatureServiceError) -> response.Response(BitArray) {
-  case error {
-    NotFound ->
-      response.Response(
-        status: 404,
-        headers: [#("content-type", "text/plain")],
-        body: <<"Not Found":utf8>>
-      )
-    Unauthorized ->
-      response.Response(
-        status: 401,
-        headers: [#("content-type", "text/plain"), #("www-authenticate", "Bearer")],
-        body: <<"Unauthorized":utf8>>
-      )
-    BadRequest(msg) ->
-      response.Response(
-        status: 400,
-        headers: [#("content-type", "text/plain")],
-        body: <<"Bad Request: ", msg:utf8>>
-      )
-    InvalidRequest(msg) ->
-      response.Response(
-        status: 400,
-        headers: [#("content-type", "text/plain")],
-        body: <<"Invalid Request: ", msg:utf8>>
-      )
-    InternalError(msg) ->
-      response.Response(
-        status: 500,
-        headers: [#("content-type", "text/plain")],
-        body: <<"Internal Error: ", msg:utf8>>
-      )
-    Unavailable(msg) ->
-      response.Response(
-        status: 503,
-        headers: [#("content-type", "text/plain"), #("retry-after", "60")],
-        body: <<"Service Unavailable: ", msg:utf8>>
-      )
+    Error(_) -> Error(DecodeError("Failed to parse query parameters"))
   }
 }
 /// Map query parameters to TemperatureRequest