Add default HTTP route for all methods

internal/examples/pets/internal/proto/buf.lock

@@ -4,5 +4,5 @@ deps:
  - remote: buf.build
  owner: googleapis
  repository: googleapis
- commit: 28151c0d0a1641bf938a7672c500e01d
- digest: shake256:49215edf8ef57f7863004539deff8834cfb2195113f0b890dd1f67815d9353e28e668019165b9d872395871eeafcbab3ccfdb2b5f11734d3cca95be9e8d139de
+ commit: 4ed3bc159a8b4ac68fe253218760d035
+ digest: shake256:7149cf5e9955c692d381e557830555d4e93f205a0f1b8e2dfdae46d029369aa3fc1980e35df0d310f7cc3b622f93e19ad276769a283a967dd3065ddfd3a40e13

internal/proto/buf.lock

@@ -4,5 +4,5 @@ deps:
  - remote: buf.build
  owner: googleapis
  repository: googleapis
- commit: 711e289f6a384c4caeebaff7c6931ade
- digest: shake256:e08fb55dad7469f69df00304eed31427d2d1576e9aab31e6bf86642688e04caaf0372f15fe6974cf79432779a635b3ea401ca69c943976dc42749524e4c25d94
+ commit: 4ed3bc159a8b4ac68fe253218760d035
+ digest: shake256:7149cf5e9955c692d381e557830555d4e93f205a0f1b8e2dfdae46d029369aa3fc1980e35df0d310f7cc3b622f93e19ad276769a283a967dd3065ddfd3a40e13

internal/proto/vanguard/test/v1/content.proto

@@ -42,6 +42,11 @@ service ContentService {
  }
  // Subscribe to updates for changes to content.
  rpc Subscribe(stream SubscribeRequest) returns (stream SubscribeResponse);
+ // Delete a file at the given path.
+ rpc Delete(DeleteRequest) returns (google.protobuf.Empty) {
+ // This method does not have an HTTP mapping, but is still callable via its
+ // default POST HTTP mapping.
+ }
 }
 
 message IndexRequest {
@@ -66,6 +71,11 @@ message DownloadResponse {
  google.api.HttpBody file = 1;
 }
 
+message DeleteRequest {
+ // The path to the file to delete.
+ string filename = 1;
+}
+
 message SubscribeRequest {
  repeated string filename_patterns = 1;
 }

transcoder.go

@@ -216,6 +216,14 @@ func (t *Transcoder) registerMethod(handler http.Handler, methodDesc protoreflec
  methodConf.streamType = connect.StreamTypeUnary
  }
 
+ // Add the default HTTP POST route for the method.
+ if err := t.addRule(&annotations.HttpRule{
+ Pattern: &annotations.HttpRule_Post{Post: methodPath},
+ Body: "*",
+ }, methodConf); err != nil {
+ return err
+ }
+ // Add the declared HTTP rules for the method.
  if httpRule, ok := getHTTPRuleExtension(methodDesc); ok {
  if err := t.addRule(httpRule, methodConf); err != nil {
  return err

vanguard.go

@@ -71,19 +71,26 @@ const (
 // The returned handler does the routing and dispatch to the RPC handlers
 // associated with each provided service. Routing supports more than just the
 // service path provided to NewService since HTTP transcoding annotations are
-// used to also support REST-ful URI paths for each method.
+// used to also support RESTful URI paths for each method.
 //
-// The returned handler also acts like a middleware, transparently "upgrading"
+// RESTful routing can be established either through google.api.http annotations in the
+// service's schema or by configuration using [WithRules]. These annotations define mappings
+// between HTTP methods and paths to RPC methods. Refer to the [annotations.HttpRule] message
+// for detailed information. By default, transcoding is provided for a POST request to the
+// service's fully-qualified name and method name. This is effectively the mapping of a
+// request of POST /GRPC_SERVICE_FULL_NAME/METHOD_NAME. No additional mappings conflicting
+// with this default mapping may be added.
+//
+// Additionally, the returned handler also acts as a middleware, transparently "upgrading"
 // the RPC handlers to support incoming request protocols they wouldn't otherwise
 // support. This can be used to upgrade Connect handlers to support REST requests
 // (based on HTTP transcoding configuration) or gRPC handlers to support Connect,
 // gRPC-Web, or REST. This can even be used with a reverse proxy handler, to
 // translate all incoming requests to a single protocol that another backend server
 // supports.
 //
-// If any options given implement ServiceOption, they are treated as default service
-// options and apply to all configured services, unless overridden by a particular
-// service.
+// Any options implementing ServiceOption are considered default service options and are applied
+// to all configured services, unless overridden by a specific service.
 func NewTranscoder(services []*Service, opts ...TranscoderOption) (*Transcoder, error) {
  for _, svc := range services {
  if svc.err != nil {
@@ -127,7 +134,6 @@ func NewTranscoder(services []*Service, opts ...TranscoderOption) (*Transcoder,
  methods: map[string]*methodConfig{},
  }
 
- var restOnlyServices []protoreflect.ServiceDescriptor
  for _, svc := range services {
  resolvedOpts := defaultServiceOptions
  for _, opt := range svc.opts {
@@ -136,33 +142,10 @@ func NewTranscoder(services []*Service, opts ...TranscoderOption) (*Transcoder,
  if err := transcoder.registerService(svc, resolvedOpts); err != nil {
  return nil, err
  }
- if len(resolvedOpts.protocols) == 1 {
- _, ok := resolvedOpts.protocols[ProtocolREST]
- if ok {
- restOnlyServices = append(restOnlyServices, svc.schema)
- }
- }
  }
  if err := transcoder.registerRules(transcoderOpts.rules); err != nil {
  return nil, err
  }
-
- // Finally, check that any services with only REST as target protocol
- // actually have at least one method with REST mappings.
- for _, svcDesc := range restOnlyServices {
- methods := svcDesc.Methods()
- var numSupportedMethods int
- for i, length := 0, methods.Len(); i < length; i++ {
- methodDesc := methods.Get(i)
- if transcoder.methods[methodPath(methodDesc)].httpRule != nil {
- numSupportedMethods++
- }
- }
- if numSupportedMethods == 0 {
- return nil, fmt.Errorf("service %s only supports REST target protocol but has no methods with HTTP rules", svcDesc.FullName())
- }
- }
-
  return transcoder, nil
 }
 

vanguard_restxrpc_test.go

@@ -237,6 +237,37 @@ func TestMux_RESTxRPC(t *testing.T) {
  code: http.StatusOK,
  body: &testv1.Book{Name: "shelves/1/books/1"},
  },
+ }, {
+ name: "GetBook-DefaultMethod",
+ input: input{
+ method: http.MethodPost,
+ path: "/vanguard.test.v1.LibraryService/GetBook",
+ body: &testv1.GetBookRequest{Name: "shelves/1/books/1"},
+ meta: http.Header{
+ "Message": []string{"hello"},
+ },
+ },
+ stream: testStream{
+ method: testv1connect.LibraryServiceGetBookProcedure,
+ reqHeader: http.Header{
+ "Message": []string{"hello"},
+ },
+ rspHeader: http.Header{
+ "Message": []string{"world"},
+ },
+ msgs: []testMsg{
+ {in: &testMsgIn{
+ msg: &testv1.GetBookRequest{Name: "shelves/1/books/1"},
+ }},
+ {out: &testMsgOut{
+ msg: &testv1.Book{Name: "shelves/1/books/1"},
+ }},
+ },
+ },
+ output: output{
+ code: http.StatusOK,
+ body: &testv1.Book{Name: "shelves/1/books/1"},
+ },
  }, {
  name: "GetBook-NotAllowed",
  input: input{

vanguard_rpcxrest_test.go

@@ -417,6 +417,28 @@ func TestMux_RPCxREST(t *testing.T) {
  },
  }},
  },
+ }, {
+ name: "Delete",
+ input: func(clients testClients, hdr http.Header) (http.Header, []proto.Message, http.Header, error) {
+ msgs := []proto.Message{
+ &testv1.DeleteRequest{Filename: "message.txt"},
+ }
+ return outputFromUnary(ctx, clients.contentClient.Delete, hdr, msgs)
+ },
+ stream: testStream{
+ method: "/vanguard.test.v1.ContentService/Delete",
+ msgs: []testMsg{
+ {in: &testMsgIn{
+ msg: &testv1.DeleteRequest{Filename: "message.txt"},
+ }},
+ {out: &testMsgOut{
+ msg: &emptypb.Empty{},
+ }},
+ },
+ },
+ output: output{
+ messages: []proto.Message{&emptypb.Empty{}},
+ },
  }}
 
  for _, opts := range testOpts {

vanguard_test.go

@@ -124,17 +124,6 @@ func TestServiceWithSchema(t *testing.T) {
  _, ok := timestampType.New().Interface().(*timestamppb.Timestamp)
  assert.True(t, ok)
  })
- t.Run("fails_for_rest_only_because_no_http_rules", func(t *testing.T) {
- t.Parallel()
- svc := NewServiceWithSchema(
- svcDesc,
- http.HandlerFunc(func(http.ResponseWriter, *http.Request) {}),
- WithTargetProtocols(ProtocolREST),
- )
-
- _, err := NewTranscoder([]*Service{svc})
- require.ErrorContains(t, err, "service foo.bar.baz.v1.BlahService only supports REST target protocol but has no methods with HTTP rules")
- })
 }
 
 func TestRuleSelector(t *testing.T) {