codegen: support mixed unary + SSE results (#3883)

Support methods that define both Result and StreamingResult with distinct types.

Generate HTTP content negotiation (JSON vs SSE), endpoint wrappers that accept a
unified input struct, and a split client API for unary vs streaming. Ensure SSE
codegen works in mixed results mode and add targeted tests.

Author: raphael

codegen/service/client_test.go

@@ -25,6 +25,7 @@ func TestClient(t *testing.T) {
 		{"client-no-payload", testdata.NoPayloadEndpointDSL, testdata.NoPayloadMethodsClient},
 		{"client-with-result", testdata.WithResultEndpointDSL, testdata.WithResultMethodClient},
 		{"client-streaming-result", testdata.StreamingResultMethodDSL, testdata.StreamingResultMethodClient},
+		{"client-mixed-results", testdata.MixedResultsEndpointDSL, testdata.MixedResultsMethodClient},
 		{"client-streaming-result-no-payload", testdata.StreamingResultNoPayloadMethodDSL, testdata.StreamingResultNoPayloadMethodClient},
 		{"client-streaming-payload", testdata.StreamingPayloadMethodDSL, testdata.StreamingPayloadMethodClient},
 		{"client-streaming-payload-no-payload", testdata.StreamingPayloadNoPayloadMethodDSL, testdata.StreamingPayloadNoPayloadMethodClient},

codegen/service/endpoint.go

@@ -44,6 +44,11 @@ type (
 		// ArgName is the name of the argument used to initialize the client
 		// struct method field.
 		ArgName string
+		// StreamArgName is the name of the argument used to initialize the client
+		// struct stream endpoint field when the method defines mixed results.
+		//
+		// It is only set when HasMixedResults is true.
+		StreamArgName string
 		// ClientVarName is the corresponding client struct field name.
 		ClientVarName string
 		// ServiceName is the name of the owner service.
@@ -142,16 +147,24 @@ func EndpointFile(genpkg string, service *expr.ServiceExpr, services *ServicesDa
 
 func endpointData(svc *Data) *EndpointsData {
 	methods := make([]*EndpointMethodData, len(svc.Methods))
-	names := make([]string, len(svc.Methods))
+	argScope := codegen.NewNameScope()
+	var names []string
 	for i, m := range svc.Methods {
+		argName := argScope.Unique(codegen.Goify(m.VarName, false), "")
+		names = append(names, argName)
+		streamArgName := ""
+		if m.HasMixedResults {
+			streamArgName = argScope.Unique(argName+"Stream", "")
+			names = append(names, streamArgName)
+		}
 		methods[i] = &EndpointMethodData{
 			MethodData:     m,
-			ArgName:        codegen.Goify(m.VarName, false),
+			ArgName:        argName,
+			StreamArgName:  streamArgName,
 			ServiceName:    svc.Name,
 			ServiceVarName: serviceInterfaceName,
 			ClientVarName:  clientStructName,
 		}
-		names[i] = codegen.Goify(m.VarName, false)
 	}
 	desc := fmt.Sprintf("%s wraps the %q service endpoints.", endpointsStructName, svc.Name)
 	return &EndpointsData{

codegen/service/endpoint_test.go

@@ -26,6 +26,7 @@ func TestEndpoint(t *testing.T) {
 		{"endpoint-with-result", testdata.WithResultEndpointDSL, testdata.WithResultEndpoint},
 		{"endpoint-with-result-multiple-views", testdata.WithResultMultipleViewsEndpointDSL, testdata.WithResultMultipleViewsEndpoint},
 		{"endpoint-streaming-result", testdata.StreamingResultEndpointDSL, testdata.StreamingResultMethodEndpoint},
+		{"endpoint-mixed-results", testdata.MixedResultsEndpointDSL, testdata.MixedResultsMethodEndpoint},
 		{"endpoint-streaming-result-no-payload", testdata.StreamingResultNoPayloadEndpointDSL, testdata.StreamingResultNoPayloadMethodEndpoint},
 		{"endpoint-streaming-result-with-views", testdata.StreamingResultWithViewsMethodDSL, testdata.StreamingResultWithViewsMethodEndpoint},
 		{"endpoint-streaming-payload", testdata.StreamingPayloadEndpointDSL, testdata.StreamingPayloadMethodEndpoint},

codegen/service/service_data.go

@@ -188,6 +188,10 @@ type (
 		// StreamKind is the kind of the stream (payload or result or
 		// bidirectional).
 		StreamKind expr.StreamKind
+		// HasMixedResults indicates whether the method defines both Result and
+		// StreamingResult with different types, enabling content negotiation at
+		// the transport layer (e.g. JSON vs SSE over HTTP).
+		HasMixedResults bool
 		// SkipRequestBodyEncodeDecode is true if the method payload includes
 		// the raw HTTP request body reader.
 		SkipRequestBodyEncodeDecode bool
@@ -206,6 +210,13 @@ type (
 		// struct to store the goa.Endpoint for this method. It is computed with a
 		// scope that includes method names to avoid field/method name collisions.
 		EndpointField string
+		// StreamEndpointField is the unique field name used in the generated client
+		// struct to store the "streaming mode" goa.Endpoint for mixed results. The
+		// transport endpoint forces server streaming (e.g. sets "Accept:
+		// text/event-stream") and returns the client stream interface.
+		//
+		// It is only set when HasMixedResults is true.
+		StreamEndpointField string
 	}
 
 	// StreamData is the data used to generate client and server interfaces that
@@ -871,6 +882,9 @@ func (d *ServicesData) analyze(service *expr.ServiceExpr) *Data {
 	// existing method names.
 	for _, m := range methods {
 		m.EndpointField = scope.Unique(m.VarName+"Endpoint", "")
+		if m.HasMixedResults {
+			m.StreamEndpointField = scope.Unique(m.VarName+"StreamEndpoint", "")
+		}
 	}
 
 	// Collect union sum-type definitions for the service.
@@ -1263,6 +1277,7 @@ func (d *ServicesData) buildMethodData(m *expr.MethodExpr, scope *codegen.NameSc
 		Requirements:                 reqs,
 		Schemes:                      schemes,
 		StreamKind:                   m.Stream,
+		HasMixedResults:              m.HasMixedResults(),
 		SkipRequestBodyEncodeDecode:  skipRequestBodyEncodeDecode,
 		SkipResponseBodyEncodeDecode: skipResponseBodyEncodeDecode,
 		RequestStruct:                vname + "RequestData",

codegen/service/service_test.go

@@ -43,6 +43,7 @@ func TestService(t *testing.T) {
 		{"service-force-generate-type", testdata.ForceGenerateTypeDSL},
 		{"service-force-generate-type-explicit", testdata.ForceGenerateTypeExplicitDSL},
 		{"service-streaming-result", testdata.StreamingResultMethodDSL},
+		{"service-mixed-results", testdata.MixedResultsEndpointDSL},
 		{"service-streaming-result-with-views", testdata.StreamingResultWithViewsMethodDSL},
 		{"service-streaming-result-with-explicit-view", testdata.StreamingResultWithExplicitViewMethodDSL},
 		{"service-streaming-result-no-payload", testdata.StreamingResultNoPayloadMethodDSL},

codegen/service/templates/service.go.tpl

@@ -25,6 +25,10 @@ type Service interface {
 	{{- if .ServerStream }}
 		{{- if and .IsJSONRPC (not .IsJSONRPCSSE) (eq .ServerStream.Kind 2) }}
 			{{ .VarName }}(context.Context{{ if .Payload }}, {{ .PayloadRef }}{{ end }}) ({{ if .Result }}res {{ .ResultRef }}, {{ end }}err error)
+		{{- else if .HasMixedResults }}
+			{{- /* Mixed results: the method may be invoked in a unary (JSON) or streaming (SSE) mode.
+			     The server stream is non-nil only when the transport negotiates streaming. */}}
+			{{ .VarName }}(context.Context{{ if .Payload }}, {{ .PayloadRef }}{{ end }}, {{ .ServerStream.Interface }}) ({{ if .Result }}res {{ .ResultRef }}, {{ end }}{{ if .ViewedResult }}{{ if not .ViewedResult.ViewName }}view string, {{ end }}{{ end }}err error)
 		{{- else }}
 			{{- if and .IsJSONRPC (not .IsJSONRPCSSE) (eq .ServerStream.Kind 3) .PayloadRef }}
 				{{- /* JSON-RPC WebSocket server streaming with non-streaming payload */ -}}

codegen/service/templates/service_client.go.tpl

@@ -2,5 +2,8 @@
 type {{ .ClientVarName }} struct {
 {{- range .Methods}}
 	{{ .EndpointField }} goa.Endpoint
+	{{- if .HasMixedResults }}
+	{{ .StreamEndpointField }} goa.Endpoint
+	{{- end }}
 {{- end }}
 }

codegen/service/templates/service_client_init.go.tpl

@@ -3,6 +3,9 @@ func New{{ .ClientVarName }}({{ .ClientInitArgs }} goa.Endpoint{{ if .HasClientI
     return &{{ .ClientVarName }}{
     {{- range .Methods }}
         {{ .EndpointField }}: {{ if .ClientInterceptors }}Wrap{{ .VarName }}ClientEndpoint({{ end }}{{ .ArgName }}{{ if .ClientInterceptors }}, ci){{ end }},
+		{{- if .HasMixedResults }}
+        {{ .StreamEndpointField }}: {{ if .ClientInterceptors }}Wrap{{ .VarName }}ClientEndpoint({{ end }}{{ .StreamArgName }}{{ if .ClientInterceptors }}, ci){{ end }},
+		{{- end }}
     {{- end }}
     }
 }

codegen/service/templates/service_client_method.go.tpl

@@ -7,6 +7,38 @@
 	{{- end }}
 //	- error: internal error
 {{- end }}
+{{- if .HasMixedResults }}
+{{- $unaryResultType := .ResultRef }}
+func (c *{{ .ClientVarName }}) {{ .VarName }}(ctx context.Context{{ if .PayloadRef }}, p {{ .PayloadRef }}{{ end }}{{ if .MethodData.SkipRequestBodyEncodeDecode}}, req io.ReadCloser{{ end }}) ({{ if $unaryResultType }}res {{ $unaryResultType }}, {{ end }}{{ if .MethodData.SkipResponseBodyEncodeDecode }}resp io.ReadCloser, {{ end }}err error) {
+	{{- if or $unaryResultType .MethodData.SkipResponseBodyEncodeDecode }}
+	var ires any
+	{{- end }}
+	{{ if or $unaryResultType .MethodData.SkipResponseBodyEncodeDecode }}ires{{ else }}_{{ end }}, err = c.{{ .EndpointField }}(ctx, {{ if .MethodData.SkipRequestBodyEncodeDecode }}&{{ .RequestStruct }}{ {{ if .PayloadRef }}Payload: p, {{ end }}Body: req }{{ else if .PayloadRef }}p{{ else }}nil{{ end }})
+	{{- if not (or $unaryResultType .MethodData.SkipResponseBodyEncodeDecode) }}
+	return
+	{{- else }}
+	if err != nil {
+		return
+	}
+		{{- if .MethodData.SkipResponseBodyEncodeDecode }}
+	o := ires.(*{{ .MethodData.ResponseStruct }})
+	return {{ if .ResultRef }}o.Result, {{ end }}o.Body, nil
+		{{- else }}
+	return ires.({{ $unaryResultType }}), nil
+		{{- end }}
+	{{- end }}
+}
+
+{{ printf "%sStream calls the %q endpoint of the %q service with server streaming enabled." .VarName .Name .ServiceName | comment }}
+func (c *{{ .ClientVarName }}) {{ .VarName }}Stream(ctx context.Context{{ if .PayloadRef }}, p {{ .PayloadRef }}{{ end }}{{ if .MethodData.SkipRequestBodyEncodeDecode}}, req io.ReadCloser{{ end }}) (res {{ .ClientStream.Interface }}, err error) {
+	var ires any
+	ires, err = c.{{ .StreamEndpointField }}(ctx, {{ if .MethodData.SkipRequestBodyEncodeDecode }}&{{ .RequestStruct }}{ {{ if .PayloadRef }}Payload: p, {{ end }}Body: req }{{ else if .PayloadRef }}p{{ else }}nil{{ end }})
+	if err != nil {
+		return
+	}
+	return ires.({{ .ClientStream.Interface }}), nil
+}
+{{- else }}
 {{- $resultType := .ResultRef }}
 {{- if .ClientStream }}
 	{{- /* When a client stream exists, always return it from the client method. */ -}}
@@ -31,3 +63,4 @@ func (c *{{ .ClientVarName }}) {{ .VarName }}(ctx context.Context{{ if .PayloadR
 		{{- end }}
 	{{- end }}
 }
+{{- end }}

codegen/service/templates/service_endpoint_method.go.tpl

@@ -120,7 +120,24 @@ func New{{ .VarName }}Endpoint(s {{ .ServiceVarName }}{{ range .Schemes.DedupeBy
 
 {{- if .ServerStream }}
 	{{- if .ServerStream.EndpointStruct }}
+		{{- if .HasMixedResults }}
+		res, {{ if .ViewedResult }}{{ if not .ViewedResult.ViewName }}view, {{ end }}{{ end }}err := s.{{ .VarName }}(ctx, {{ if .PayloadRef }}{{ $payload }}, {{ end }}ep.Stream)
+		if err != nil {
+			return nil, err
+		}
+			{{- if .ViewedResult }}
+				{{- if .ViewedResult.ViewName }}
+		vres := {{ $.ViewedResult.Init.Name }}(res, {{ printf "%q" .ViewedResult.ViewName }})
+				{{- else }}
+		vres := {{ $.ViewedResult.Init.Name }}(res, view)
+				{{- end }}
+		return vres, nil
+			{{- else }}
+		return res, nil
+			{{- end }}
+		{{- else }}
 		return nil, s.{{ .VarName }}(ctx, {{ if .PayloadRef }}{{ $payload }}, {{ end }}ep.Stream)
+		{{- end }}
 	{{- else }}
 		{{- /* JSON-RPC WebSocket client streaming: no stream parameter, just payload */ -}}
 		{{- if .PayloadRef }}