feat: method namer

Author: chris-4chain

client.go

@@ -98,6 +98,7 @@ func NewClient(ctx context.Context, addr string, namespace string, handler inter
 
 type client struct {
 	namespace     string
+	methodNamer   MethodNamer
 	paramEncoders map[reflect.Type]ParamEncoder
 	errors        *Errors
 
@@ -139,6 +140,7 @@ func NewCustomClient(namespace string, outs []interface{}, doRequest func(ctx co
 
 	c := client{
 		namespace:     namespace,
+		methodNamer:   config.methodNamer,
 		paramEncoders: config.paramEncoders,
 		errors:        config.errors,
 	}
@@ -193,6 +195,7 @@ func NewCustomClient(namespace string, outs []interface{}, doRequest func(ctx co
 func httpClient(ctx context.Context, addr string, namespace string, outs []interface{}, requestHeader http.Header, config Config) (ClientCloser, error) {
 	c := client{
 		namespace:     namespace,
+		methodNamer:   config.methodNamer,
 		paramEncoders: config.paramEncoders,
 		errors:        config.errors,
 	}
@@ -288,6 +291,7 @@ func websocketClient(ctx context.Context, addr string, namespace string, outs []
 
 	c := client{
 		namespace:     namespace,
+		methodNamer:   config.methodNamer,
 		paramEncoders: config.paramEncoders,
 		errors:        config.errors,
 	}
@@ -710,7 +714,7 @@ func (c *client) makeRpcFunc(f reflect.StructField) (reflect.Value, error) {
 		return reflect.Value{}, xerrors.New("handler field not a func")
 	}
 
-	name := c.namespace + "." + f.Name
+	name := c.methodNamer(c.namespace, f.Name)
 	if tag, ok := f.Tag.Lookup(ProxyTagRPCMethod); ok {
 		name = tag
 	}

handler.go

@@ -78,6 +78,8 @@ type handler struct {
 	paramDecoders map[reflect.Type]ParamDecoder
 
 	tracer Tracer
+
+	methodNamer MethodNamer
 }
 
 type Tracer func(method string, params []reflect.Value, results []reflect.Value, err error)
@@ -93,6 +95,8 @@ func makeHandler(sc ServerConfig) *handler {
 		maxRequestSize: sc.maxRequestSize,
 
 		tracer: sc.tracer,
+
+		methodNamer: sc.methodNamer,
 	}
 }
 
@@ -126,7 +130,7 @@ func (s *handler) register(namespace string, r interface{}) {
 
 		valOut, errOut, _ := processFuncOut(funcType)
 
-		s.methods[namespace+"."+method.Name] = methodHandler{
+		s.methods[s.methodNamer(namespace, method.Name)] = methodHandler{
 			paramReceivers: recvs,
 			nParams:        ins,
 

namer.go

@@ -0,0 +1,25 @@
+package jsonrpc
+
+import "strings"
+
+// MethodNamer is a function that takes a namespace and a method name and returns the full method name, sent via JSON-RPC.
+// This is useful if you want to customize the default behaviour, e.g. send without the namespace or make it lowercase.
+type MethodNamer func(string, string) string
+
+// DefaultMethodNamer joins the namespace and method name with a dot.
+func DefaultMethodNamer(namespace, method string) string {
+	return namespace + "." + method
+}
+
+// NoNamespaceMethodNamer returns the method name as is, without the namespace.
+func NoNamespaceMethodNamer(_, method string) string {
+	return method
+}
+
+// NoNamespaceDecapitalizedMethodNamer returns the method name as is, without the namespace, and decapitalizes the first letter.
+func NoNamespaceDecapitalizedMethodNamer(_, method string) string {
+	if len(method) == 0 {
+		return ""
+	}
+	return strings.ToLower(method[:1]) + method[1:]
+}

namer_test.go

@@ -0,0 +1,113 @@
+package jsonrpc
+
+import (
+	"context"
+	"fmt"
+	"github.com/stretchr/testify/require"
+	"net/http"
+	"net/http/httptest"
+	"strings"
+	"testing"
+)
+
+func TestDifferentMethodNamers(t *testing.T) {
+	tests := map[string]struct {
+		namer MethodNamer
+
+		requestedMethod string
+	}{
+		"default namer": {
+			namer:           DefaultMethodNamer,
+			requestedMethod: "SimpleServerHandler.Inc",
+		},
+		"no namespace namer": {
+			namer:           NoNamespaceMethodNamer,
+			requestedMethod: "Inc",
+		},
+		"no namespace & decapitalized namer": {
+			namer:           NoNamespaceDecapitalizedMethodNamer,
+			requestedMethod: "inc",
+		},
+	}
+	for name, test := range tests {
+		t.Run(name, func(t *testing.T) {
+			rpcServer := NewServer(WithServerMethodNamer(test.namer))
+
+			serverHandler := &SimpleServerHandler{}
+			rpcServer.Register("SimpleServerHandler", serverHandler)
+
+			testServ := httptest.NewServer(rpcServer)
+			defer testServ.Close()
+
+			req := fmt.Sprintf(`{"jsonrpc": "2.0", "method": "%s", "params": [], "id": 1}`, test.requestedMethod)
+
+			res, err := http.Post(testServ.URL, "application/json", strings.NewReader(req))
+			require.NoError(t, err)
+
+			require.Equal(t, http.StatusOK, res.StatusCode)
+			require.Equal(t, int32(1), serverHandler.n)
+		})
+	}
+}
+
+func TestDifferentMethodNamersWithClient(t *testing.T) {
+	tests := map[string]struct {
+		namer     MethodNamer
+		urlPrefix string
+	}{
+		"default namer & http": {
+			namer:     DefaultMethodNamer,
+			urlPrefix: "http://",
+		},
+		"default namer & ws": {
+			namer:     DefaultMethodNamer,
+			urlPrefix: "ws://",
+		},
+		"no namespace namer & http": {
+			namer:     NoNamespaceMethodNamer,
+			urlPrefix: "http://",
+		},
+		"no namespace namer & ws": {
+			namer:     NoNamespaceMethodNamer,
+			urlPrefix: "ws://",
+		},
+		"no namespace & decapitalized namer & http": {
+			namer:     NoNamespaceDecapitalizedMethodNamer,
+			urlPrefix: "http://",
+		},
+		"no namespace & decapitalized namer & ws": {
+			namer:     NoNamespaceDecapitalizedMethodNamer,
+			urlPrefix: "ws://",
+		},
+	}
+	for name, test := range tests {
+		t.Run(name, func(t *testing.T) {
+			rpcServer := NewServer(WithServerMethodNamer(test.namer))
+
+			serverHandler := &SimpleServerHandler{}
+			rpcServer.Register("SimpleServerHandler", serverHandler)
+
+			testServ := httptest.NewServer(rpcServer)
+			defer testServ.Close()
+
+			var client struct {
+				AddGet func(int) int
+			}
+
+			closer, err := NewMergeClient(
+				context.Background(),
+				test.urlPrefix+testServ.Listener.Addr().String(),
+				"SimpleServerHandler",
+				[]any{&client},
+				nil,
+				WithHTTPClient(testServ.Client()),
+				WithMethodNamer(test.namer),
+			)
+			require.NoError(t, err)
+			defer closer()
+
+			n := client.AddGet(123)
+			require.Equal(t, 123, n)
+		})
+	}
+}

options.go

@@ -30,6 +30,8 @@ type Config struct {
 
 	noReconnect      bool
 	proxyConnFactory func(func() (*websocket.Conn, error)) func() (*websocket.Conn, error) // for testing
+
+	methodNamer MethodNamer
 }
 
 func defaultConfig() Config {
@@ -46,6 +48,8 @@ func defaultConfig() Config {
 		paramEncoders: map[reflect.Type]ParamEncoder{},
 
 		httpClient: _defaultHTTPClient,
+
+		methodNamer: DefaultMethodNamer,
 	}
 }
 
@@ -110,3 +114,9 @@ func WithHTTPClient(h *http.Client) func(c *Config) {
 		c.httpClient = h
 	}
 }
+
+func WithMethodNamer(namer MethodNamer) func(c *Config) {
+	return func(c *Config) {
+		c.methodNamer = namer
+	}
+}

options_server.go

@@ -22,6 +22,8 @@ type ServerConfig struct {
 
 	reverseClientBuilder func(context.Context, *wsConn) (context.Context, error)
 	tracer               Tracer
+
+	methodNamer MethodNamer
 }
 
 type ServerOption func(c *ServerConfig)
@@ -32,6 +34,8 @@ func defaultServerConfig() ServerConfig {
 		maxRequestSize: DEFAULT_MAX_REQUEST_SIZE,
 
 		pingInterval: 5 * time.Second,
+
+		methodNamer: DefaultMethodNamer,
 	}
 }
 
@@ -74,6 +78,7 @@ func WithReverseClient[RP any](namespace string) ServerOption {
 		c.reverseClientBuilder = func(ctx context.Context, conn *wsConn) (context.Context, error) {
 			cl := client{
 				namespace:     namespace,
+				methodNamer:   c.methodNamer,
 				paramEncoders: map[reflect.Type]ParamEncoder{},
 			}
 
@@ -114,3 +119,9 @@ func ExtractReverseClient[C any](ctx context.Context) (C, bool) {
 
 	return *c, ok
 }
+
+func WithServerMethodNamer(namer MethodNamer) ServerOption {
+	return func(c *ServerConfig) {
+		c.methodNamer = namer
+	}
+}