feat: SendRequest and SendNotification now uses ellipsis for parameters

cmaglie · cmaglie · commit 442cf1d6be9a · 2025-12-17T11:46:37.000+01:00
diff --git a/examples/generic_sock_client/main.go b/examples/generic_sock_client/main.go
@@ -59,7 +59,7 @@ func main() {
 			args = append(args, arg)
 		}
 	}
-	reqResult, reqError, err := conn.SendRequest(context.Background(), method, args)
+	reqResult, reqError, err := conn.SendRequest(context.Background(), method, args...)
 	if err != nil {
 		fmt.Println("Error sending request:", err)
 		return
diff --git a/examples/mult_server/main.go b/examples/mult_server/main.go
@@ -61,7 +61,7 @@ func main() {
 
 	// Register the ping method
 	ctx := context.Background()
-	_, reqErr, err := conn.SendRequest(ctx, "$/register", []any{"mult"})
+	_, reqErr, err := conn.SendRequest(ctx, "$/register", "mult")
 	if err != nil {
 		slog.Error("Failed to send register request for ping method", "err", err)
 		return
diff --git a/examples/ping_client/main.go b/examples/ping_client/main.go
@@ -34,7 +34,7 @@ func main() {
 	go conn.Run()
 
 	// Client
-	reqResult, reqError, err := conn.SendRequest(context.Background(), "ping", []any{"HELLO", 1, true, 5.0})
+	reqResult, reqError, err := conn.SendRequest(context.Background(), "ping", "HELLO", 1, true, 5.0)
 	if err != nil {
 		panic(err)
 	}
diff --git a/examples/ping_server/main.go b/examples/ping_server/main.go
@@ -50,7 +50,7 @@ func main() {
 
 	// Register the ping method
 	ctx := context.Background()
-	_, reqErr, err := conn.SendRequest(ctx, "$/register", []any{"ping"})
+	_, reqErr, err := conn.SendRequest(ctx, "$/register", "ping")
 	if err != nil {
 		slog.Error("Failed to send register request for ping method", "err", reqErr)
 		return
diff --git a/internal/msgpackrouter/router.go b/internal/msgpackrouter/router.go
@@ -129,7 +129,7 @@ func (r *Router) connectionLoop(conn io.ReadWriteCloser) {
 			}
 
 			// Forward the call to the registered client
-			reqResult, reqError, err := client.SendRequest(ctx, method, params)
+			reqResult, reqError, err := client.SendRequest(ctx, method, params...)
 			if err != nil {
 				slog.Error("Failed to send request", "method", method, "err", err)
 				return nil, routerError(ErrCodeFailedToSendRequests, fmt.Sprintf("failed to send request: %s", err))
@@ -157,7 +157,7 @@ func (r *Router) connectionLoop(conn io.ReadWriteCloser) {
 			}
 
 			// Forward the notification to the registered client
-			if err := client.SendNotification(method, params); err != nil {
+			if err := client.SendNotification(method, params...); err != nil {
 				slog.Error("Failed to send notification", "method", method, "err", err)
 				return
 			}
diff --git a/internal/msgpackrouter/router_test.go b/internal/msgpackrouter/router_test.go
@@ -98,59 +98,59 @@ func TestBasicRouterFunctionality(t *testing.T) {
 
 	{
 		// Register a method on the first client
-		result, reqErr, err := cl1.SendRequest(context.Background(), "$/register", []any{"ping"})
+		result, reqErr, err := cl1.SendRequest(context.Background(), "$/register", "ping")
 		require.Equal(t, true, result)
 		require.Nil(t, reqErr)
 		require.NoError(t, err)
 	}
 	{
 		// Try to re-register the same method
-		result, reqErr, err := cl1.SendRequest(context.Background(), "$/register", []any{"ping"})
+		result, reqErr, err := cl1.SendRequest(context.Background(), "$/register", "ping")
 		require.Nil(t, result)
 		require.Equal(t, []any{int8(msgpackrouter.ErrCodeRouteAlreadyExists), "route already exists: ping"}, reqErr)
 		require.NoError(t, err)
 	}
 	{
 		// Register a method on the second client
-		result, reqErr, err := cl2.SendRequest(context.Background(), "$/register", []any{"temperature"})
+		result, reqErr, err := cl2.SendRequest(context.Background(), "$/register", "temperature")
 		require.Equal(t, true, result)
 		require.Nil(t, reqErr)
 		require.NoError(t, err)
 	}
 	{
 		// Call from client2 the registered method on client1
-		result, reqErr, err := cl2.SendRequest(context.Background(), "ping", []any{"1", 2, true})
+		result, reqErr, err := cl2.SendRequest(context.Background(), "ping", "1", 2, true)
 		require.Equal(t, []any{"1", int8(2), true}, result)
 		require.Nil(t, reqErr)
 		require.NoError(t, err)
 	}
 	{
 		// Self-call from client1
-		result, reqErr, err := cl1.SendRequest(context.Background(), "ping", []any{"c", 12, false})
+		result, reqErr, err := cl1.SendRequest(context.Background(), "ping", "c", 12, false)
 		require.Equal(t, []any{"c", int8(12), false}, result)
 		require.Nil(t, reqErr)
 		require.NoError(t, err)
 	}
 	{
 		// Call from client2 an un-registered method
-		result, reqErr, err := cl2.SendRequest(context.Background(), "not-existent-method", []any{"1", 2, true})
+		result, reqErr, err := cl2.SendRequest(context.Background(), "not-existent-method", "1", 2, true)
 		require.Nil(t, result)
 		require.Equal(t, []any{int8(msgpackrouter.ErrCodeMethodNotAvailable), "method not-existent-method not available"}, reqErr)
 		require.NoError(t, err)
 	}
 	{
 		// Send notification to client1
-		err := cl2.SendNotification("ping", []any{"a", int16(4), false})
+		err := cl2.SendNotification("ping", "a", int16(4), false)
 		require.NoError(t, err)
 	}
 	{
 		// Send notification to unregistered method
-		err := cl2.SendNotification("notexistent", []any{"a", int16(4), false})
+		err := cl2.SendNotification("notexistent", "a", int16(4), false)
 		require.NoError(t, err)
 	}
 	{
 		// Self-send notification
-		err := cl1.SendNotification("ping", []any{"b", int16(14), true, true})
+		err := cl1.SendNotification("ping", "b", int16(14), true, true)
 		require.NoError(t, err)
 	}
 	time.Sleep(100 * time.Millisecond) // Give some time for the notifications to be processed
@@ -190,7 +190,7 @@ func TestMessageForwarderCongestionControl(t *testing.T) {
 
 	{
 		// Register a method on the first client
-		result, reqErr, err := cl1.SendRequest(context.Background(), "$/register", []any{"test"})
+		result, reqErr, err := cl1.SendRequest(context.Background(), "$/register", "test")
 		require.Equal(t, true, result)
 		require.Nil(t, reqErr)
 		require.NoError(t, err)
@@ -201,7 +201,7 @@ func TestMessageForwarderCongestionControl(t *testing.T) {
 	var wg sync.WaitGroup
 	for range batchSize {
 		wg.Go(func() {
-			_, _, err := cl2.SendRequest(t.Context(), "test", []any{})
+			_, _, err := cl2.SendRequest(t.Context(), "test")
 			require.NoError(t, err)
 		})
 	}
diff --git a/msgpackrpc/connection.go b/msgpackrpc/connection.go
@@ -327,7 +327,10 @@ func (c *Connection) Close() {
 	_ = c.out.Close()
 }
 
-func (c *Connection) SendRequest(ctx context.Context, method string, params []any) (reqResult any, reqError any, err error) {
+func (c *Connection) SendRequest(ctx context.Context, method string, params ...any) (reqResult any, reqError any, err error) {
+	if params == nil {
+		params = []any{}
+	}
 	id := MessageID(c.lastOutRequestsIndex.Add(1))
 
 	c.loggerMutex.Lock()
@@ -364,7 +367,7 @@ func (c *Connection) SendRequest(ctx context.Context, method string, params []an
 			c.logger.LogOutgoingCancelRequest(id)
 			c.loggerMutex.Unlock()
 
-			_ = c.SendNotification("$/cancelRequest", []any{id}) // ignore error (it won't matter anyway)
+			_ = c.SendNotification("$/cancelRequest", id) // ignore error (it won't matter anyway)
 		}
 
 		// After cancelation wait for result...
@@ -378,7 +381,11 @@ func (c *Connection) SendRequest(ctx context.Context, method string, params []an
 	return result.reqResult, result.reqError, nil
 }
 
-func (c *Connection) SendNotification(method string, params []any) error {
+func (c *Connection) SendNotification(method string, params ...any) error {
+	if params == nil {
+		params = []any{}
+	}
+
 	c.loggerMutex.Lock()
 	c.logger.LogOutgoingNotification(method, params)
 	c.loggerMutex.Unlock()
diff --git a/msgpackrpc/connection_rpc_test.go b/msgpackrpc/connection_rpc_test.go
@@ -130,7 +130,7 @@ func TestRPCConnection(t *testing.T) {
 		wg.Add(1)
 		go func() {
 			defer wg.Done()
-			respRes, respErr, err := conn.SendRequest(t.Context(), "helloworld", []any{true})
+			respRes, respErr, err := conn.SendRequest(t.Context(), "helloworld", true)
 			require.NoError(t, err)
 			require.Nil(t, respErr)
 			require.Equal(t, map[string]any{"fakedata": int8(99)}, respRes)

Original file line number	Diff line number	Diff line change
`@@ -59,7 +59,7 @@ func main() {`
`59`	`59`	`args = append(args, arg)`
`60`	`60`	`}`
`61`	`61`	`}`
`62`		`- reqResult, reqError, err := conn.SendRequest(context.Background(), method, args)`
	`62`	`+ reqResult, reqError, err := conn.SendRequest(context.Background(), method, args...)`
`63`	`63`	`if err != nil {`
`64`	`64`	`fmt.Println("Error sending request:", err)`
`65`	`65`	`return`
Original file line number	Diff line number	Diff line change
`@@ -34,7 +34,7 @@ func main() {`
`34`	`34`	`go conn.Run()`
`35`	`35`
`36`	`36`	`// Client`
`37`		`- reqResult, reqError, err := conn.SendRequest(context.Background(), "ping", []any{"HELLO", 1, true, 5.0})`
	`37`	`+ reqResult, reqError, err := conn.SendRequest(context.Background(), "ping", "HELLO", 1, true, 5.0)`
`38`	`38`	`if err != nil {`
`39`	`39`	`panic(err)`
`40`	`40`	`}`
Original file line number	Diff line number	Diff line change
`@@ -129,7 +129,7 @@ func (r *Router) connectionLoop(conn io.ReadWriteCloser) {`
`129`	`129`	`}`
`130`	`130`
`131`	`131`	`// Forward the call to the registered client`
`132`		`- reqResult, reqError, err := client.SendRequest(ctx, method, params)`
	`132`	`+ reqResult, reqError, err := client.SendRequest(ctx, method, params...)`
`133`	`133`	`if err != nil {`
`134`	`134`	`slog.Error("Failed to send request", "method", method, "err", err)`
`135`	`135`	`return nil, routerError(ErrCodeFailedToSendRequests, fmt.Sprintf("failed to send request: %s", err))`
`@@ -157,7 +157,7 @@ func (r *Router) connectionLoop(conn io.ReadWriteCloser) {`
`157`	`157`	`}`
`158`	`158`
`159`	`159`	`// Forward the notification to the registered client`
`160`		`- if err := client.SendNotification(method, params); err != nil {`
	`160`	`+ if err := client.SendNotification(method, params...); err != nil {`
`161`	`161`	`slog.Error("Failed to send notification", "method", method, "err", err)`
`162`	`162`	`return`
`163`	`163`	`}`
Original file line number	Diff line number	Diff line change
`@@ -98,59 +98,59 @@ func TestBasicRouterFunctionality(t *testing.T) {`
`98`	`98`
`99`	`99`	`{`
`100`	`100`	`// Register a method on the first client`
`101`		`- result, reqErr, err := cl1.SendRequest(context.Background(), "$/register", []any{"ping"})`
	`101`	`+ result, reqErr, err := cl1.SendRequest(context.Background(), "$/register", "ping")`
`102`	`102`	`require.Equal(t, true, result)`
`103`	`103`	`require.Nil(t, reqErr)`
`104`	`104`	`require.NoError(t, err)`
`105`	`105`	`}`
`106`	`106`	`{`
`107`	`107`	`// Try to re-register the same method`
`108`		`- result, reqErr, err := cl1.SendRequest(context.Background(), "$/register", []any{"ping"})`
	`108`	`+ result, reqErr, err := cl1.SendRequest(context.Background(), "$/register", "ping")`
`109`	`109`	`require.Nil(t, result)`
`110`	`110`	`require.Equal(t, []any{int8(msgpackrouter.ErrCodeRouteAlreadyExists), "route already exists: ping"}, reqErr)`
`111`	`111`	`require.NoError(t, err)`
`112`	`112`	`}`
`113`	`113`	`{`
`114`	`114`	`// Register a method on the second client`
`115`		`- result, reqErr, err := cl2.SendRequest(context.Background(), "$/register", []any{"temperature"})`
	`115`	`+ result, reqErr, err := cl2.SendRequest(context.Background(), "$/register", "temperature")`
`116`	`116`	`require.Equal(t, true, result)`
`117`	`117`	`require.Nil(t, reqErr)`
`118`	`118`	`require.NoError(t, err)`
`119`	`119`	`}`
`120`	`120`	`{`
`121`	`121`	`// Call from client2 the registered method on client1`
`122`		`- result, reqErr, err := cl2.SendRequest(context.Background(), "ping", []any{"1", 2, true})`
	`122`	`+ result, reqErr, err := cl2.SendRequest(context.Background(), "ping", "1", 2, true)`
`123`	`123`	`require.Equal(t, []any{"1", int8(2), true}, result)`
`124`	`124`	`require.Nil(t, reqErr)`
`125`	`125`	`require.NoError(t, err)`
`126`	`126`	`}`
`127`	`127`	`{`
`128`	`128`	`// Self-call from client1`
`129`		`- result, reqErr, err := cl1.SendRequest(context.Background(), "ping", []any{"c", 12, false})`
	`129`	`+ result, reqErr, err := cl1.SendRequest(context.Background(), "ping", "c", 12, false)`
`130`	`130`	`require.Equal(t, []any{"c", int8(12), false}, result)`
`131`	`131`	`require.Nil(t, reqErr)`
`132`	`132`	`require.NoError(t, err)`
`133`	`133`	`}`
`134`	`134`	`{`
`135`	`135`	`// Call from client2 an un-registered method`
`136`		`- result, reqErr, err := cl2.SendRequest(context.Background(), "not-existent-method", []any{"1", 2, true})`
	`136`	`+ result, reqErr, err := cl2.SendRequest(context.Background(), "not-existent-method", "1", 2, true)`
`137`	`137`	`require.Nil(t, result)`
`138`	`138`	`require.Equal(t, []any{int8(msgpackrouter.ErrCodeMethodNotAvailable), "method not-existent-method not available"}, reqErr)`
`139`	`139`	`require.NoError(t, err)`
`140`	`140`	`}`
`141`	`141`	`{`
`142`	`142`	`// Send notification to client1`
`143`		`- err := cl2.SendNotification("ping", []any{"a", int16(4), false})`
	`143`	`+ err := cl2.SendNotification("ping", "a", int16(4), false)`
`144`	`144`	`require.NoError(t, err)`
`145`	`145`	`}`
`146`	`146`	`{`
`147`	`147`	`// Send notification to unregistered method`
`148`		`- err := cl2.SendNotification("notexistent", []any{"a", int16(4), false})`
	`148`	`+ err := cl2.SendNotification("notexistent", "a", int16(4), false)`
`149`	`149`	`require.NoError(t, err)`
`150`	`150`	`}`
`151`	`151`	`{`
`152`	`152`	`// Self-send notification`
`153`		`- err := cl1.SendNotification("ping", []any{"b", int16(14), true, true})`
	`153`	`+ err := cl1.SendNotification("ping", "b", int16(14), true, true)`
`154`	`154`	`require.NoError(t, err)`
`155`	`155`	`}`
`156`	`156`	`time.Sleep(100 * time.Millisecond) // Give some time for the notifications to be processed`
`@@ -190,7 +190,7 @@ func TestMessageForwarderCongestionControl(t *testing.T) {`
`190`	`190`
`191`	`191`	`{`
`192`	`192`	`// Register a method on the first client`
`193`		`- result, reqErr, err := cl1.SendRequest(context.Background(), "$/register", []any{"test"})`
	`193`	`+ result, reqErr, err := cl1.SendRequest(context.Background(), "$/register", "test")`
`194`	`194`	`require.Equal(t, true, result)`
`195`	`195`	`require.Nil(t, reqErr)`
`196`	`196`	`require.NoError(t, err)`
`@@ -201,7 +201,7 @@ func TestMessageForwarderCongestionControl(t *testing.T) {`
`201`	`201`	`var wg sync.WaitGroup`
`202`	`202`	`for range batchSize {`
`203`	`203`	`wg.Go(func() {`
`204`		`- _, _, err := cl2.SendRequest(t.Context(), "test", []any{})`
	`204`	`+ _, _, err := cl2.SendRequest(t.Context(), "test")`
`205`	`205`	`require.NoError(t, err)`
`206`	`206`	`})`
`207`	`207`	`}`