feat: responsebody generation (default) and remove path params from request body

Author: amirsalarsafaei

protoc-gen-openapiv3/internal/genopenapiv3/file_generator.go

@@ -30,13 +30,17 @@ func (fg *fileGenerator) generateFileDoc(file *descriptor.File) *openapi3.T {
 
 	fg.doc.Components = new(openapi3.Components)
 	fg.doc.Components.Schemas = make(openapi3.Schemas)
+	fg.doc.Components.RequestBodies = make(openapi3.RequestBodies)
 
 	if fg.doc.Paths == nil {
 		fg.doc.Paths = &openapi3.Paths{}
 	}
 
 	for _, svc := range file.Services {
-		fg.generateServiceDoc(svc)
+		err := fg.generateServiceDoc(svc)
+		if err != nil {
+			grpclog.Errorf("could not generate service document: %v", err)
+		}
 	}
 
 	for _, msg := range file.Messages {
@@ -77,6 +81,10 @@ func (fg *fileGenerator) generateMessageSchema(msg *descriptor.Message, excludeF
 	properties := make(openapi3.Schemas)
 	tempOneOfsProperties := make(map[int32]openapi3.Schemas)
 	for _, field := range msg.Fields {
+		if slices.Contains(excludeFields, field.FQFN()) {
+			continue
+		}
+
 		fieldDoc := fg.generateFieldDoc(field)
 		if field.OneofIndex != nil {
 			if tempOneOfsProperties[*field.OneofIndex] == nil {
@@ -254,10 +262,15 @@ func (fg *fileGenerator) generateEnumSchema(enum *descriptor.Enum) *openapi3.Sch
 	}
 }
 
-func (fg *fileGenerator) generateServiceDoc(svc *descriptor.Service) {
+func (fg *fileGenerator) generateServiceDoc(svc *descriptor.Service) error {
 	for _, meth := range svc.Methods {
-		fg.generateMethodDoc(meth)
+		err := fg.generateMethodDoc(meth)
+		if err != nil {
+			return fmt.Errorf("could not generate method %s doc: %w", meth.GetName(), err)
+		}
 	}
+
+	return nil
 }
 
 func (fg *fileGenerator) generateMethodDoc(meth *descriptor.Method) error {
@@ -279,26 +292,52 @@ func (fg *fileGenerator) generateMethodDoc(meth *descriptor.Method) error {
 				params = append(params, tmpParams...)
 			}
 
+			pathParamsFQFNs := make([]string, len(binding.PathParams))
+			for i, param := range binding.PathParams {
+				pathParamsFQFNs[i] = param.Target.FQFN()
+			}
+
 			switch binding.HTTPMethod {
 			case "POST", "PUT", "PATCH":
 				// For POST, PUT, PATCH, add request body
-				requestBody = &openapi3.RequestBodyRef{Value: openapi3.NewRequestBody().WithContent(
-					openapi3.NewContentWithJSONSchemaRef(fg.getMessageSchemaRef(meth.RequestType)))}
+				if len(pathParamsFQFNs) > 0 {
+					messageSchema := fg.generateMessageSchema(meth.RequestType, pathParamsFQFNs)
+
+					name := fg.resolveName(meth.RequestType.FQMN())
+					resultRef := fmt.Sprintf("#/components/requestBodies/%s", name)
 
+					fg.doc.Components.RequestBodies[name] = &openapi3.RequestBodyRef{Value: openapi3.NewRequestBody().WithContent(
+						openapi3.NewContentWithJSONSchemaRef(messageSchema.NewRef()))}
+
+					requestBody = &openapi3.RequestBodyRef{Ref: resultRef}
+				} else {
+					requestBody = &openapi3.RequestBodyRef{Value: openapi3.NewRequestBody().
+						WithJSONSchemaRef(fg.getMessageSchemaRef(meth.RequestType))}
+				}
 			}
 		}
 
-		responseSchema := &openapi3.ResponseRef{
-			Ref: fg.getMessageSchemaRef(meth.ResponseType).RefString(),
+		defaultResponse, err := fg.defaultResponse()
+		if err != nil {
+			return fmt.Errorf("could not get default response: %w", err)
 		}
 
+		successResponseSchema := openapi3.NewResponse().
+			WithJSONSchemaRef(fg.getMessageSchemaRef(meth.ResponseType))
+
+		defaultResponseSchema := openapi3.NewResponse().
+			WithJSONSchemaRef(fg.getMessageSchemaRef(defaultResponse))
+
+		responses := openapi3.NewResponses(openapi3.WithStatus(200, &openapi3.ResponseRef{Value: successResponseSchema}),
+			openapi3.WithName("default", defaultResponseSchema))
+
 		operation := &openapi3.Operation{
 			Tags:        []string{meth.Service.GetName()},
 			Summary:     opOpts.GetSummary(),
 			Description: opOpts.GetDescription(),
 			OperationID: fg.getOperationName(meth.Service.GetName(), meth.GetName(), bindingIdx),
 			RequestBody: requestBody,
-			Responses:   openapi3.NewResponses(openapi3.WithStatus(200, responseSchema)),
+			Responses:   responses,
 			Parameters:  params,
 		}
 
@@ -370,13 +409,13 @@ func (fg *fileGenerator) messageToParameters(message *descriptor.Message,
 
 		switch paramType {
 		case openapi3.ParameterInPath:
-			param := openapi3.NewPathParameter(field.GetJsonName())
+			param := openapi3.NewPathParameter(field.GetName())
 			param.Schema = schema
 			params = append(params, &openapi3.ParameterRef{
 				Value: param,
 			})
 		case openapi3.ParameterInQuery:
-			param := openapi3.NewQueryParameter(field.GetJsonName())
+			param := openapi3.NewQueryParameter(field.GetName())
 			param.Schema = schema
 			params = append(params, &openapi3.ParameterRef{
 				Value: param,

protoc-gen-openapiv3/internal/genopenapiv3/generator.go

@@ -9,9 +9,11 @@ import (
 	"github.com/grpc-ecosystem/grpc-gateway/v2/internal/descriptor"
 	gen "github.com/grpc-ecosystem/grpc-gateway/v2/internal/generator"
 	"github.com/grpc-ecosystem/grpc-gateway/v2/protoc-gen-openapiv3/options"
-	"google.golang.org/grpc/grpclog"
+	statuspb "google.golang.org/genproto/googleapis/rpc/status"
 	"google.golang.org/protobuf/proto"
+	"google.golang.org/protobuf/reflect/protodesc"
 	"google.golang.org/protobuf/types/descriptorpb"
+	"google.golang.org/protobuf/types/known/anypb"
 	"google.golang.org/protobuf/types/pluginpb"
 )
 
@@ -28,6 +30,11 @@ func NewGenerator(reg *descriptor.Registry, format Format) gen.Generator {
 }
 
 func (g *generator) Generate(targets []*descriptor.File) ([]*descriptor.ResponseFile, error) {
+	err := g.loadPrequisiteProtos()
+	if err != nil {
+		return nil, fmt.Errorf("could not load prequisite proto files in registry: %w", err)
+	}
+
 	respFiles := make([]*descriptor.ResponseFile, len(targets))
 	for i, t := range targets {
 		fileGenerator := &fileGenerator{generator: g, doc: &openapi3.T{}}
@@ -70,15 +77,30 @@ func (g *generator) fqmnToLocation(fqmn string) string {
 }
 
 func (g *generator) resolveName(fqmn string) string {
-	grpclog.Infof("resolveFQMN: %s", fqmn)
 	return fqmn
 }
 
 func (g *generator) resolveType(typeName string) string {
-	grpclog.Infof("resolveType: %s", typeName)
 	return typeName
 }
 
+func (g *generator) loadPrequisiteProtos() error {
+	any := protodesc.ToFileDescriptorProto((&anypb.Any{}).ProtoReflect().Descriptor().ParentFile())
+	any.SourceCodeInfo = new(descriptorpb.SourceCodeInfo)
+	status := protodesc.ToFileDescriptorProto((&statuspb.Status{}).ProtoReflect().Descriptor().ParentFile())
+	status.SourceCodeInfo = new(descriptorpb.SourceCodeInfo)
+	return g.reg.Load(&pluginpb.CodeGeneratorRequest{
+		ProtoFile: []*descriptorpb.FileDescriptorProto{
+			any,
+			status,
+		},
+	})
+}
+
+func (g *generator) defaultResponse() (*descriptor.Message, error) {
+	return g.reg.LookupMsg("", ".google.rpc.Status")
+}
+
 func extractOperationOptionFromMethodDescriptor(meth *descriptorpb.MethodDescriptorProto) (*options.Operation, error) {
 	if meth.Options == nil {
 		return &options.Operation{}, nil

protoc-gen-openapiv3/internal/genopenapiv3/types.go

@@ -40,8 +40,3 @@ const (
 	OneOfStrategyOneOf = "oneof"
 	OneOfStrategyAllOf = "allof"
 )
-
-type methodDoc struct{
-	operation *openapi3.Operation
-	externalSchemas []*openapi3.Schema
-}