feat: add service struct generation to protoc-gen-connect-go

Signed-off-by: Yordis Prieto <yordis.prieto@gmail.com>

Author: yordis

cmd/protoc-gen-connect-go/internal/testdata/defaultpackage/gen/genconnect/defaultpackage.connect.go

@@ -270,6 +270,7 @@ func generateService(g *protogen.GeneratedFile, file *protogen.File, service *pr
 	generateClientInterface(g, service, names)
 	generateClientImplementation(g, file, service, names)
 	generateServerInterface(g, service, names)
+	generateServiceImplementation(g, file, service, names)
 	generateServerConstructor(g, file, service, names)
 	generateUnimplementedServerImplementation(g, service, names)
 }
@@ -432,6 +433,74 @@ func generateServerInterface(g *protogen.GeneratedFile, service *protogen.Servic
 	g.P()
 }
 
+func generateServiceImplementation(g *protogen.GeneratedFile, file *protogen.File, service *protogen.Service, names names) {
+	// Service struct - make it public
+	wrapComments(g, names.Service, " provides access to the handlers for the ", service.Desc.FullName(), " service.")
+	if isDeprecatedService(service) {
+		g.P("//")
+		deprecated(g)
+	}
+	g.AnnotateSymbol(names.Service, protogen.Annotation{Location: service.Location})
+	g.P("type ", names.Service, " struct {")
+	for _, method := range service.Methods {
+		fieldName := method.GoName + "Func"
+		g.AnnotateSymbol(names.Service+"."+fieldName, protogen.Annotation{Location: method.Location})
+		leadingComments(
+			g,
+			method.Comments.Leading,
+			isDeprecatedMethod(method),
+		)
+		// Use connect function types where available, fall back to full signatures
+		if !method.Desc.IsStreamingClient() && !method.Desc.IsStreamingServer() {
+			// Unary method - use HandlerFunc
+			g.P(fieldName, " ", connectPackage.Ident("HandlerFunc"), "[", method.Input.GoIdent, ", ", method.Output.GoIdent, "]")
+		} else if method.Desc.IsStreamingClient() && method.Desc.IsStreamingServer() {
+			// Bidirectional streaming - use BidiStreamFunc
+			g.P(fieldName, " ", connectPackage.Ident("BidiStreamFunc"), "[", method.Input.GoIdent, ", ", method.Output.GoIdent, "]")
+		} else {
+			// Client or server streaming - use full function signature (no dedicated func types available)
+			g.P(fieldName, " func", serverSignatureParams(g, method, false))
+		}
+	}
+	g.P("}")
+	g.P()
+	
+	// Generate methods that delegate to the handler functions to make the Service struct
+	// implement the Handler interface (backwards compatible)
+	for _, method := range service.Methods {
+		fieldName := method.GoName + "Func"
+		wrapComments(g, method.GoName, " calls the ", method.GoName, "Func handler.")
+		if isDeprecatedMethod(method) {
+			g.P("//")
+			deprecated(g)
+		}
+		// Use named parameters for the method signature
+		methodSig := method.GoName + serverSignatureParams(g, method, true /* named */)
+		g.P("func (s *", names.Service, ") ", methodSig, " {")
+		
+		// Handle different method types
+		isStreamingClient := method.Desc.IsStreamingClient()
+		isStreamingServer := method.Desc.IsStreamingServer()
+		
+		switch {
+		case isStreamingClient && isStreamingServer:
+			// Bidirectional streaming: (ctx, stream)
+			g.P("return s.", fieldName, "(ctx, stream)")
+		case isStreamingClient && !isStreamingServer:
+			// Client streaming: (ctx, stream)
+			g.P("return s.", fieldName, "(ctx, stream)")
+		case !isStreamingClient && isStreamingServer:
+			// Server streaming: (ctx, req, stream)
+			g.P("return s.", fieldName, "(ctx, req, stream)")
+		default:
+			// Unary: (ctx, req)
+			g.P("return s.", fieldName, "(ctx, req)")
+		}
+		g.P("}")
+		g.P()
+	}
+}
+
 func generateServerConstructor(g *protogen.GeneratedFile, file *protogen.File, service *protogen.Service, names names) {
 	wrapComments(g, names.ServerConstructor, " builds an HTTP handler from the service implementation.",
 		" It returns the path on which to mount the handler and the handler itself.")
@@ -667,6 +736,7 @@ type names struct {
 	Server              string
 	ServerConstructor   string
 	UnimplementedServer string
+	Service             string
 }
 
 func newNames(service *protogen.Service) names {
@@ -679,5 +749,6 @@ func newNames(service *protogen.Service) names {
 		Server:              fmt.Sprintf("%sHandler", base),
 		ServerConstructor:   fmt.Sprintf("New%sHandler", base),
 		UnimplementedServer: fmt.Sprintf("Unimplemented%sHandler", base),
+		Service:             fmt.Sprintf("%sService", base),
 	}
 }

cmd/protoc-gen-connect-go/internal/testdata/diffpackage/gen/gendiff/diffpackage.connect.go

@@ -217,6 +217,120 @@ func TestClientHandler(t *testing.T) {
 	})
 }
 
+func TestServiceStruct(t *testing.T) {
+	t.Parallel()
+	ctx := context.Background()
+	
+	t.Run("TestServiceService struct exists and works", func(t *testing.T) {
+		t.Parallel()
+		svc := testSamePackageService{}
+		
+		service := &samepackage.TestServiceService{
+			MethodFunc: svc.Method,
+		}
+		
+		assert.NotNil(t, service.MethodFunc)
+		
+		// Test that the service struct implements the handler interface
+		methodHandler := connect.NewUnaryHandler(
+			samepackage.TestServiceMethodProcedure,
+			service.Method, // Use the method, not the function field
+		)
+		
+		server := httptest.NewServer(methodHandler)
+		defer server.Close()
+		
+		client := samepackage.NewTestServiceClient(server.Client(), server.URL)
+		rsp, err := client.Method(ctx, connect.NewRequest(&samepackage.Request{}))
+		assert.Nil(t, err)
+		assert.NotNil(t, rsp)
+	})
+	
+	t.Run("TestServiceService can be used for custom routing", func(t *testing.T) {
+		t.Parallel()
+		svc := testSamePackageService{}
+		
+		service := &samepackage.TestServiceService{
+			MethodFunc: svc.Method,
+		}
+		
+		methodHandler := connect.NewUnaryHandler(
+			samepackage.TestServiceMethodProcedure,
+			service.Method,
+		)
+		
+		mux := http.NewServeMux()
+		mux.Handle(samepackage.TestServiceMethodProcedure, methodHandler)
+		
+		server := httptest.NewServer(mux)
+		defer server.Close()
+		
+		client := samepackage.NewTestServiceClient(server.Client(), server.URL)
+		rsp, err := client.Method(ctx, connect.NewRequest(&samepackage.Request{}))
+		assert.Nil(t, err)
+		assert.NotNil(t, rsp)
+	})
+	
+	t.Run("TestServiceService implements Handler interface (backwards compatible)", func(t *testing.T) {
+		t.Parallel()
+		svc := testSamePackageService{}
+		
+		service := &samepackage.TestServiceService{
+			MethodFunc: svc.Method,
+		}
+		
+		// The Service struct should implement the Handler interface
+		var handler samepackage.TestServiceHandler = service
+		assert.NotNil(t, handler)
+		
+		// Test that we can use the service directly as a handler
+		_, httpHandler := samepackage.NewTestServiceHandler(service)
+		server := httptest.NewServer(httpHandler)
+		defer server.Close()
+		
+		client := samepackage.NewTestServiceClient(server.Client(), server.URL)
+		rsp, err := client.Method(ctx, connect.NewRequest(&samepackage.Request{}))
+		assert.Nil(t, err)
+		assert.NotNil(t, rsp)
+	})
+}
+
+func TestServiceStructGeneration(t *testing.T) {
+	t.Parallel()
+	
+	t.Run("generated code contains Service struct", func(t *testing.T) {
+		t.Parallel()
+		samePackageFileDesc := protodesc.ToFileDescriptorProto(samepackage.File_samepackage_proto)
+		compilerVersion := &pluginpb.Version{
+			Major:  ptr(int32(0)),
+			Minor:  ptr(int32(0)),
+			Patch:  ptr(int32(1)),
+			Suffix: ptr("test"),
+		}
+		
+		req := &pluginpb.CodeGeneratorRequest{
+			FileToGenerate:        []string{"samepackage.proto"},
+			Parameter:             ptr("package_suffix"),
+			ProtoFile:             []*descriptorpb.FileDescriptorProto{samePackageFileDesc},
+			SourceFileDescriptors: []*descriptorpb.FileDescriptorProto{samePackageFileDesc},
+			CompilerVersion:       compilerVersion,
+		}
+		
+		rsp := testGenerate(t, req)
+		assert.Nil(t, rsp.Error)
+		assert.Equal(t, len(rsp.File), 1)
+		
+		file := rsp.File[0]
+		content := file.GetContent()
+		
+		assert.True(t, strings.Contains(content, "type TestServiceService struct"))
+		assert.True(t, strings.Contains(content, "MethodFunc connect.HandlerFunc[Request, Response]"))
+		assert.True(t, strings.Contains(content, "TestServiceService provides access to the handlers"))
+		assert.True(t, strings.Contains(content, "func (s *TestServiceService) Method(ctx context.Context, req *connect.Request[Request]) (*connect.Response[Response], error)"))
+		assert.True(t, strings.Contains(content, "return s.MethodFunc(ctx, req)"))
+	})
+}
+
 func testCmpToTestdata(t *testing.T, content, path string) {
 	t.Helper()
 	b, err := testdata.ReadFile(path)

cmd/protoc-gen-connect-go/internal/testdata/samepackage/gen/samepackage.connect.go

@@ -19,6 +19,14 @@ import (
 	"net/http"
 )
 
+// HandlerFunc is a function that implements the Handler interface.
+// It is used to create a Handler from a function.
+type HandlerFunc[Req, Res any] func(context.Context, *Request[Req]) (*Response[Res], error)
+
+// BidiStreamFunc is a function that implements the BidiStream interface.
+// It is used to create a BidiStream from a function.
+type BidiStreamFunc[Req, Res any] func(context.Context, *BidiStream[Req, Res]) error
+
 // A Handler is the server-side implementation of a single RPC defined by a
 // service schema.
 //