Expose request method of unary requests to clients and server handlers

client.go

@@ -77,6 +77,11 @@ func NewClient[Req, Res any](httpClient HTTPClient, url string, options ...Clien
 	unarySpec := config.newSpec(StreamTypeUnary)
 	unaryFunc := UnaryFunc(func(ctx context.Context, request AnyRequest) (AnyResponse, error) {
 		conn := client.protocolClient.NewConn(ctx, unarySpec, request.Header())
+		if hasRequestMethod, ok := conn.(clientConnWithRequestMethod); ok {
+			hasRequestMethod.onSetMethod(func(method string) {
+				request.setRequestMethod(method)
+			})
+		}
 		// Send always returns an io.EOF unless the error is from the client-side.
 		// We want the user to continue to call Receive in those cases to get the
 		// full error from the server-side.

connect.go

@@ -135,6 +135,7 @@ type Request[T any] struct {
 	spec   Spec
 	peer   Peer
 	header http.Header
+	method string
 }
 
 // NewRequest wraps a generated request message.
@@ -172,9 +173,27 @@ func (r *Request[_]) Header() http.Header {
 	return r.header
 }
 
+// Method returns the HTTP method for this request. This is nearly always
+// POST, but side-effect-free RPCs could be made via a GET.
+//
+// On a newly created request, via NewRequest, this will return "POST" and
+// only changes to return to "GET" after it is actually sent to a server
+// using GET as the method.
+func (r *Request[_]) Method() string {
+	if r.method == "" {
+		return http.MethodPost
+	}
+	return r.method
+}
+
 // internalOnly implements AnyRequest.
 func (r *Request[_]) internalOnly() {}
 
+// setRequestMethod sets the request method to the given value.
+func (r *Request[_]) setRequestMethod(method string) {
+	r.method = method
+}
+
 // AnyRequest is the common method set of every [Request], regardless of type
 // parameter. It's used in unary interceptors.
 //
@@ -190,8 +209,10 @@ type AnyRequest interface {
 	Spec() Spec
 	Peer() Peer
 	Header() http.Header
+	Method() string
 
 	internalOnly()
+	setRequestMethod(string)
 }
 
 // Response is a wrapper around a generated response message. It provides
@@ -315,6 +336,16 @@ type handlerConnCloser interface {
 	Close(error) error
 }
 
+type handlerConnWithRequestMethod interface {
+	StreamingHandlerConn
+	getMethod() string
+}
+
+type clientConnWithRequestMethod interface {
+	StreamingClientConn
+	onSetMethod(fn func(string))
+}
+
 // receiveUnaryResponse unmarshals a message from a StreamingClientConn, then
 // envelopes the message and attaches headers and trailers. It attempts to
 // consume the response stream and isn't appropriate when receiving multiple

duplex_http_call.go

@@ -33,6 +33,7 @@ type duplexHTTPCall struct {
 	ctx              context.Context
 	httpClient       HTTPClient
 	streamType       StreamType
+	onSetMethod      func(method string)
 	validateResponse func(*http.Response) *Error
 
 	// We'll use a pipe as the request body. We hand the read side of the pipe to
@@ -150,6 +151,9 @@ func (d *duplexHTTPCall) URL() *url.URL {
 // SetMethod changes the method of the request before it is sent.
 func (d *duplexHTTPCall) SetMethod(method string) {
 	d.request.Method = method
+	if d.onSetMethod != nil {
+		d.onSetMethod(method)
+	}
 }
 
 // Read from the response body. Returns the first error passed to SetError.

handler.go

@@ -67,11 +67,16 @@ func NewUnaryHandler[Req, Res any](
 		if err := conn.Receive(&msg); err != nil {
 			return err
 		}
+		method := http.MethodPost
+		if hasRequestMethod, ok := conn.(handlerConnWithRequestMethod); ok {
+			method = hasRequestMethod.getMethod()
+		}
 		request := &Request[Req]{
 			Msg:    &msg,
 			spec:   conn.Spec(),
 			peer:   conn.Peer(),
 			header: conn.RequestHeader(),
+			method: method,
 		}
 		response, err := untyped(ctx, request)
 		if err != nil {

protocol_connect.go

@@ -499,6 +499,10 @@ func (cc *connectUnaryClientConn) CloseResponse() error {
 	return cc.duplexCall.CloseRead()
 }
 
+func (cc *connectUnaryClientConn) onSetMethod(fn func(string)) {
+	cc.duplexCall.onSetMethod = fn
+}
+
 func (cc *connectUnaryClientConn) validateResponse(response *http.Response) *Error {
 	for k, v := range response.Header {
 		if !strings.HasPrefix(k, connectUnaryTrailerPrefix) {
@@ -719,6 +723,10 @@ func (hc *connectUnaryHandlerConn) Close(err error) error {
 	return hc.request.Body.Close()
 }
 
+func (hc *connectUnaryHandlerConn) getMethod() string {
+	return hc.request.Method
+}
+
 func (hc *connectUnaryHandlerConn) writeResponseHeader(err error) {
 	header := hc.responseWriter.Header()
 	if hc.request.Method == http.MethodGet {
@@ -928,7 +936,7 @@ type connectUnaryRequestMarshaler struct {
 func (m *connectUnaryRequestMarshaler) Marshal(message any) *Error {
 	if m.enableGet {
 		if m.stableCodec == nil && !m.getUseFallback {
-			return errorf(CodeInternal, "codec %s doesn't support stable marshal; cam't use get", m.codec.Name())
+			return errorf(CodeInternal, "codec %s doesn't support stable marshal; can't use get", m.codec.Name())
 		}
 		if m.stableCodec != nil {
 			return m.marshalWithGet(message)