grpc-gateway protoc-gen-swagger: support maps in query parameters

Hi guys, having following definition:

message Test {
    map<string, string> filters = 1;
}

service TestService {
    rpc TestRpc(Test) returns (Test) {
        option (google.api.http) = {
            get: "/test"
        };
    }
}

Which goes through swagger generator and ends up without the map being mentioend as parameters in request:

"/test": {
      "get": {
        "operationId": "TestRpc",
        "responses": {
          "200": {
            "description": "A successful response.",
            "schema": {
              "$ref": "#/definitions/offersTest"
            }
          }
        },
        "tags": [
          "TestService"
        ]
      }
    }

I thought that I can add map params to the query... but I dont think so now and I cant tell if it's a bug... KR Jirka

Aug 06 '19 11:08 george-oakling

Thanks for the bug report! A few questions:

What does the generated gateway look like? Is it trying to parse the map from the query? If so, that would be a large indicator that we should be supporting this and that it's a bug in the swagger generator.
Does it work even if you disregard the generated swagger docs?

Aug 06 '19 12:08 johanbrandhorst

test.proto:

message TestRequest {
    map<string, string> filters = 1;
}

message TestResponse {
}

service TestSvc {
    rpc TestRpc(TestRequest) returns(TestResponse) {
        option (google.api.http) = {
            get: "/offers"
        };
    }
}

test.pb.gw.go

var (
	filter_TestSvc_TestRpc_0 = &utilities.DoubleArray{Encoding: map[string]int{}, Base: []int(nil), Check: []int(nil)}
)

func request_TestSvc_TestRpc_0(ctx context.Context, marshaler runtime.Marshaler, client TestSvcClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
	var protoReq TestRequest
	var metadata runtime.ServerMetadata

	if err := req.ParseForm(); err != nil {
		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
	}
	if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_TestSvc_TestRpc_0); err != nil {
		return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
	}

	msg, err := client.TestRpc(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
	return msg, metadata, err

}
...
func RegisterTestSvcHandlerClient(ctx context.Context, mux *runtime.ServeMux, client TestSvcClient) error {

	mux.Handle("GET", pattern_TestSvc_TestRpc_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
		ctx, cancel := context.WithCancel(req.Context())
		defer cancel()
		inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
		rctx, err := runtime.AnnotateContext(ctx, mux, req)
		if err != nil {
			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
			return
		}
		resp, md, err := request_TestSvc_TestRpc_0(rctx, inboundMarshaler, client, req, pathParams)
		ctx = runtime.NewServerMetadataContext(ctx, md)
		if err != nil {
			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
			return
		}

		forward_TestSvc_TestRpc_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)

	})

	return nil
}

test.swagger

      "get": {
        "operationId": "TestRpc",
        "responses": {
          "200": {
            "description": "A successful response.",
            "schema": {
              "$ref": "#/definitions/offersTestResponse"
            }
          }
        },
        "tags": [
          "TestSvc"
        ]
      }