Replace authn.Request for *http.Request

authn.go

@@ -19,6 +19,7 @@ import (
 	"context"
 	"fmt"
 	"net/http"
+	"strings"
 
 	"connectrpc.com/connect"
 )
@@ -69,6 +70,40 @@ func Errorf(template string, args ...any) *connect.Error {
 	return connect.NewError(connect.CodeUnauthenticated, fmt.Errorf(template, args...))
 }
 
+// InferProtocol returns the inferred RPC protocol. It is one of
+// [connect.ProtocolConnect], [connect.ProtocolGRPC], or [connect.ProtocolGRPCWeb].
+func InferProtocol(request *http.Request) string {
+	ct := request.Header.Get("Content-Type")
+	switch {
+	case strings.HasPrefix(ct, "application/grpc-web"):
+		return connect.ProtocolGRPCWeb
+	case strings.HasPrefix(ct, "application/grpc"):
+		return connect.ProtocolGRPC
+	default:
+		return connect.ProtocolConnect
+	}
+}
+
+// InferProcedure returns the inferred RPC procedure. It is of the form
+// "/service/method". If the request path does not contain a procedure name, the
+// entire path is returned.
+func InferProcedure(request *http.Request) string {
+	path := strings.TrimSuffix(request.URL.Path, "/")
+	ultimate := strings.LastIndex(path, "/")
+	if ultimate < 0 {
+		return request.URL.Path
+	}
+	penultimate := strings.LastIndex(path[:ultimate], "/")
+	if penultimate < 0 {
+		return request.URL.Path
+	}
+	procedure := path[penultimate:]
+	if len(procedure) < 4 { // two slashes + service + method
+		return request.URL.Path
+	}
+	return procedure
+}
+
 // Middleware is server-side HTTP middleware that authenticates RPC requests.
 // In addition to rejecting unauthenticated requests, it can optionally attach
 // arbitrary information about the authenticated identity to the context.

authn_test.go

@@ -23,6 +23,7 @@
 	"testing"
 
 	"connectrpc.com/authn"
+	"connectrpc.com/connect"
 	"github.com/stretchr/testify/assert"
 )
 
@@ -105,3 +106,59 @@
 	}
 	return hero, nil
 }
+
+func TestInferProcedures(t *testing.T) {
+	t.Parallel()
+	testProcedures := [][2]string{
+		{"/empty.v1/GetEmpty", "/empty.v1/GetEmpty"},
+		{"/empty.v1/GetEmpty/", "/empty.v1/GetEmpty"},
+		{"/empty.v1/GetEmpty/", "/empty.v1/GetEmpty"},
+		{"/prefix/empty.v1/GetEmpty/", "/empty.v1/GetEmpty"},
+		{"/", "/"},
+		{"/invalid/", "/invalid/"},
+	}
+	for _, tt := range testProcedures {
+		req := httptest.NewRequest(http.MethodPost, tt[0], strings.NewReader("{}"))
+		assert.Equal(t, tt[1], authn.InferProcedure(req))
+	}
+}
+
+func TestInferProtocol(t *testing.T) {
+	t.Parallel()
+	tests := []struct {
+		name         string
+		contentType  string
+		method       string
+		wantProtocol string
+	}{{
+		name:         "connect",
+		contentType:  "application/json",
+		wantProtocol: connect.ProtocolConnect,
+	}, {
+		name:         "connectSubPath",
+		contentType:  "application/connect+json",
+		wantProtocol: connect.ProtocolConnect,
+	}, {
+		name:         "grpc",
+		contentType:  "application/grpc+proto",
+		wantProtocol: connect.ProtocolGRPC,
+	}, {
+		name:         "grpcWeb",
+		contentType:  "application/grpc-web",
+		wantProtocol: connect.ProtocolGRPCWeb,
+	}, {
+		name:         "grpcWeb",
+		contentType:  "application/grpc-web+json",
+		wantProtocol: connect.ProtocolGRPCWeb,
+	}}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			t.Parallel()
+			req := httptest.NewRequest(http.MethodPost, "/service/Method", strings.NewReader("{}"))
+			if tt.contentType != "" {
+				req.Header.Set("Content-Type", tt.contentType)
+			}
+			assert.Equal(t, tt.wantProtocol, authn.InferProtocol(req))
+		})
+	}
+}