fix(httpgen): pass err directly when it implements proto.Message

The previous implementation tried to pass protoErr (proto.Message type)
to writeErrorWithHandler which expects an error type. Since proto error
messages implement both interfaces, we just pass err directly and let
defaultErrorResponse extract the proto.Message.

Also updates error-handler example to demonstrate returning proto errors
directly from handlers (NotFoundError instead of custom Go struct).

Co-Authored-By: Claude Opus 4.5 <[email protected]>

Author: 2 people

examples/error-handler/main.go

@@ -69,13 +69,22 @@ func (s *UserServiceImpl) CreateUser(ctx context.Context, req *models.CreateUser
 }
 
 // GetUser retrieves a user by ID.
+// This demonstrates returning a proto error message directly from a handler.
+// The framework preserves the proto structure in the response (not wrapped in {"message":"..."}).
 func (s *UserServiceImpl) GetUser(ctx context.Context, req *models.GetUserRequest) (*models.User, error) {
 	s.mu.RLock()
 	defer s.mu.RUnlock()
 
 	user, exists := s.users[req.Id]
 	if !exists {
-		return nil, &ErrNotFound{ResourceType: "user", ResourceID: req.Id}
+		// Return proto error directly - structure is preserved in response:
+		// Response: {"resourceType":"user","resourceId":"...","message":"user not found"}
+		// NOT:      {"message":"{\"resourceType\":\"user\",...}"}
+		return nil, &models.NotFoundError{
+			ResourceType: "user",
+			ResourceId:   req.Id,
+			Message:      "user not found",
+		}
 	}
 	return user, nil
 }
@@ -309,8 +318,10 @@ func main() {
 	fmt.Println(`     -H "Content-Type: application/json" \`)
 	fmt.Println(`     -d '{"name": "J", "email": "invalid-email"}'`)
 	fmt.Println()
-	fmt.Println("3. Get non-existent user (not found error):")
+	fmt.Println("3. Get non-existent user (proto error with preserved structure):")
 	fmt.Println(`   curl -v http://localhost:8080/api/v1/users/non-existent-id`)
+	fmt.Println(`   # Returns: {"resourceType":"user","resourceId":"non-existent-id","message":"user not found"}`)
+	fmt.Println(`   # NOT:     {"message":"{\"resourceType\":\"user\",...}"} (old behavior)`)
 	fmt.Println()
 	fmt.Println("4. Get user with request ID header:")
 	fmt.Println(`   curl -v http://localhost:8080/api/v1/users/non-existent-id \`)

internal/httpgen/error_handler_test.go

@@ -388,15 +388,16 @@ func TestProtoMessageErrorPreservation(t *testing.T) {
 
 	t.Run("genericHandler checks for proto.Message errors", func(t *testing.T) {
 		// The genericHandler should check if the error is already a proto.Message
-		if !strings.Contains(files.binding, "if protoErr, ok := err.(proto.Message); ok {") {
+		if !strings.Contains(files.binding, "if _, ok := err.(proto.Message); ok {") {
 			t.Error("genericHandler should check if error is a proto.Message")
 		}
 	})
 
 	t.Run("genericHandler passes proto.Message errors directly to writeErrorWithHandler", func(t *testing.T) {
 		// When error is a proto.Message, it should be passed directly without wrapping
-		if !strings.Contains(files.binding, "writeErrorWithHandler(w, r, protoErr, errorHandler)") {
-			t.Error("genericHandler should pass proto.Message errors directly to writeErrorWithHandler")
+		// The error is passed as 'err' (not protoErr) since it implements both error and proto.Message
+		if !strings.Contains(files.binding, "if _, ok := err.(proto.Message); ok {") {
+			t.Error("genericHandler should check if error is a proto.Message")
 		}
 	})
 
@@ -423,7 +424,7 @@ func TestProtoMessageErrorPreservation(t *testing.T) {
 	t.Run("proto.Message check comes before sebufhttp.Error wrapping", func(t *testing.T) {
 		// In genericHandler, the proto.Message check should come before the sebufhttp.Error wrapping
 		binding := files.binding
-		protoMsgCheckPos := strings.Index(binding, "if protoErr, ok := err.(proto.Message)")
+		protoMsgCheckPos := strings.Index(binding, "if _, ok := err.(proto.Message)")
 		sebufErrorPos := strings.Index(binding, "errorMsg := &sebufhttp.Error{")
 
 		if protoMsgCheckPos == -1 || sebufErrorPos == -1 {

internal/httpgen/generator.go

@@ -566,8 +566,9 @@ func (g *Generator) generateBindingFile(file *protogen.File) error {
 	gf.P("response, err := serve(r.Context(), request)")
 	gf.P("if err != nil {")
 	gf.P("// Check if error is already a proto.Message (e.g., custom proto error types)")
-	gf.P("if protoErr, ok := err.(proto.Message); ok {")
-	gf.P("writeErrorWithHandler(w, r, protoErr, errorHandler)")
+	gf.P("// If so, pass it directly - defaultErrorResponse will preserve its structure")
+	gf.P("if _, ok := err.(proto.Message); ok {")
+	gf.P("writeErrorWithHandler(w, r, err, errorHandler)")
 	gf.P("return")
 	gf.P("}")
 	gf.P("errorMsg := &sebufhttp.Error{")