Better compatibility with grpc Ruby generated code.

Author: samuel-williams-shopify

context/getting-started.md

@@ -39,12 +39,27 @@ This gem provides protocol-level abstractions only. To actually send requests ov
 require "protocol/grpc/interface"
 
 class GreeterInterface < Protocol::GRPC::Interface
-	rpc :SayHello, request_class: Hello::HelloRequest, response_class: Hello::HelloReply
-	rpc :SayHelloAgain, request_class: Hello::HelloRequest, response_class: Hello::HelloReply,
-						streaming: :server_streaming
+	# Unary RPC (single request, single response)
+	rpc :SayHello, Hello::HelloRequest, Hello::HelloReply
+	
+	# Server streaming RPC using stream() decorator
+	rpc :SayHelloMany, Hello::HelloRequest, stream(Hello::HelloReply)
+	
+	# Client streaming RPC
+	rpc :SayHelloRepeatedly, stream(Hello::HelloRequest), Hello::HelloReply
+	
+	# Bidirectional streaming RPC
+	rpc :ChatHello, stream(Hello::HelloRequest), stream(Hello::HelloReply)
 end
 ```
 
+The `stream()` decorator marks message types as streamed. You can also use the keyword syntax:
+
+``` ruby
+rpc :SayHelloAgain, request_class: Hello::HelloRequest, response_class: Hello::HelloReply,
+	streaming: :server_streaming
+```
+
 ### Building a Request
 
 Build gRPC requests using `Protocol::GRPC::Methods` and `Protocol::GRPC::Body::Writable`:

guides/getting-started/readme.md

@@ -39,12 +39,27 @@ This gem provides protocol-level abstractions only. To actually send requests ov
 require "protocol/grpc/interface"
 
 class GreeterInterface < Protocol::GRPC::Interface
-	rpc :SayHello, request_class: Hello::HelloRequest, response_class: Hello::HelloReply
-	rpc :SayHelloAgain, request_class: Hello::HelloRequest, response_class: Hello::HelloReply,
-						streaming: :server_streaming
+	# Unary RPC (single request, single response)
+	rpc :SayHello, Hello::HelloRequest, Hello::HelloReply
+	
+	# Server streaming RPC using stream() decorator
+	rpc :SayHelloMany, Hello::HelloRequest, stream(Hello::HelloReply)
+	
+	# Client streaming RPC
+	rpc :SayHelloRepeatedly, stream(Hello::HelloRequest), Hello::HelloReply
+	
+	# Bidirectional streaming RPC
+	rpc :ChatHello, stream(Hello::HelloRequest), stream(Hello::HelloReply)
 end
 ```
 
+The `stream()` decorator marks message types as streamed. You can also use the keyword syntax:
+
+``` ruby
+rpc :SayHelloAgain, request_class: Hello::HelloRequest, response_class: Hello::HelloReply,
+	streaming: :server_streaming
+```
+
 ### Building a Request
 
 Build gRPC requests using `Protocol::GRPC::Methods` and `Protocol::GRPC::Body::Writable`:

lib/protocol/grpc/interface.rb

@@ -7,6 +7,17 @@
 
 module Protocol
 	module GRPC
+		# Wrapper class to mark a message type as streamed.
+		# Used with the stream() helper method in RPC definitions.
+		class Streaming
+			def initialize(message_class)
+				@message_class = message_class
+			end
+			
+			# @attribute [Class] The wrapped message class
+			attr :message_class
+		end
+		
 		# Represents an interface definition for gRPC methods.
 		# Can be used by both client stubs and server implementations.
 		class Interface
@@ -24,6 +35,21 @@ def streaming?
 				end
 			end
 
+			# Helper method to mark a message type as streamed in RPC definitions.
+			# Can be called directly within Interface subclasses without the Protocol::GRPC prefix.
+			# @parameter message_class [Class] The message class to mark as streamed
+			# @returns [Streaming] A wrapper indicating this type is streamed
+			# 
+			# @example Define streaming RPCs
+			#   class MyService < Protocol::GRPC::Interface
+			#     rpc :sum, stream(Num), Num              # client streaming
+			#     rpc :fib, FibArgs, stream(Num)          # server streaming
+			#     rpc :chat, stream(Msg), stream(Msg)     # bidirectional streaming
+			#   end
+			def self.stream(message_class)
+				Streaming.new(message_class)
+			end
+			
 			# Hook called when a subclass is created.
 			# Initializes the RPC hash for the subclass.
 			# @parameter subclass [Class] The subclass being created
@@ -35,13 +61,41 @@ def self.inherited(subclass)
 
 			# Define an RPC method.
 			# @parameter name [Symbol] Method name in PascalCase (e.g., :SayHello, matching .proto file)
-			# @parameter request_class [Class] Request message class
-			# @parameter response_class [Class] Response message class
+			# @parameter request_class [Class | Streaming] Request message class, optionally wrapped with stream()
+			# @parameter response_class [Class | Streaming] Response message class, optionally wrapped with stream()
 			# @parameter streaming [Symbol] Streaming type (:unary, :server_streaming, :client_streaming, :bidirectional)
+			#   This is automatically inferred from stream() decorators if not explicitly provided
 			# @parameter method [Symbol | Nil] Optional explicit Ruby method name (snake_case). If not provided, automatically converts PascalCase to snake_case.
-			def self.rpc(name, **options)
+			# 
+			# @example Using stream() decorator syntax
+			#   rpc :div, DivArgs, DivReply                      # unary
+			#   rpc :sum, stream(Num), Num                       # client streaming
+			#   rpc :fib, FibArgs, stream(Num)                   # server streaming
+			#   rpc :chat, stream(DivArgs), stream(DivReply)     # bidirectional streaming
+			def self.rpc(name, request_class = nil, response_class = nil, **options)
 				options[:name] = name
 
+				# Check if request or response are wrapped with stream()
+				request_streaming = request_class.is_a?(Streaming)
+				response_streaming = response_class.is_a?(Streaming)
+				
+				# Unwrap StreamWrapper if present
+				options[:request_class] ||= request_streaming ? request_class.message_class : request_class
+				options[:response_class] ||= response_streaming ? response_class.message_class : response_class
+				
+				# Auto-detect streaming type from stream() decorators if not explicitly set
+				if !options.key?(:streaming)
+					if request_streaming && response_streaming
+						options[:streaming] = :bidirectional
+					elsif request_streaming
+						options[:streaming] = :client_streaming
+					elsif response_streaming
+						options[:streaming] = :server_streaming
+					else
+						options[:streaming] = :unary
+					end
+				end
+				
 				# Ensure snake_case method name is always available
 				options[:method] ||= pascal_case_to_snake_case(name.to_s).to_sym
 

test/protocol/grpc/body/readable.rb

@@ -138,3 +138,4 @@ def write_message(message, compressed: false)
 end
 
 
+

test/protocol/grpc/body/writable.rb

@@ -298,3 +298,4 @@ def wrong_message.to_proto
 end
 
 
+

test/protocol/grpc/interface.rb

@@ -301,4 +301,129 @@
 			expect(rpc.method).to be == :greet_user
 		end
 	end
+	
+	with "stream() decorator syntax" do
+		it "supports unary RPC (no stream)" do
+			request_class = self.request_class
+			response_class = self.response_class
+			
+			interface_class = Class.new(Protocol::GRPC::Interface) do
+				rpc :div, request_class, response_class
+			end
+			
+			rpc = interface_class.lookup_rpc(:div)
+			expect(rpc.name).to be == :div
+			expect(rpc.request_class).to be == request_class
+			expect(rpc.response_class).to be == response_class
+			expect(rpc.streaming).to be == :unary
+			expect(rpc.streaming?).to be == false
+		end
+		
+		it "supports client streaming with stream() on request" do
+			request_class = self.request_class
+			response_class = self.response_class
+			
+			interface_class = Class.new(Protocol::GRPC::Interface) do
+				rpc :sum, stream(request_class), response_class
+			end
+			
+			rpc = interface_class.lookup_rpc(:sum)
+			expect(rpc.name).to be == :sum
+			expect(rpc.request_class).to be == request_class
+			expect(rpc.response_class).to be == response_class
+			expect(rpc.streaming).to be == :client_streaming
+			expect(rpc.streaming?).to be == true
+		end
+		
+		it "supports server streaming with stream() on response" do
+			request_class = self.request_class
+			response_class = self.response_class
+			
+			interface_class = Class.new(Protocol::GRPC::Interface) do
+				rpc :fib, request_class, stream(response_class)
+			end
+			
+			rpc = interface_class.lookup_rpc(:fib)
+			expect(rpc.name).to be == :fib
+			expect(rpc.request_class).to be == request_class
+			expect(rpc.response_class).to be == response_class
+			expect(rpc.streaming).to be == :server_streaming
+			expect(rpc.streaming?).to be == true
+		end
+		
+		it "supports bidirectional streaming with stream() on both" do
+			request_class = self.request_class
+			response_class = self.response_class
+			
+			interface_class = Class.new(Protocol::GRPC::Interface) do
+				rpc :div_many, stream(request_class), stream(response_class)
+			end
+			
+			rpc = interface_class.lookup_rpc(:div_many)
+			expect(rpc.name).to be == :div_many
+			expect(rpc.request_class).to be == request_class
+			expect(rpc.response_class).to be == response_class
+			expect(rpc.streaming).to be == :bidirectional
+			expect(rpc.streaming?).to be == true
+		end
+		
+		it "explicit streaming option overrides stream() decorator" do
+			request_class = self.request_class
+			response_class = self.response_class
+			
+			interface_class = Class.new(Protocol::GRPC::Interface) do
+				rpc :custom, stream(request_class), response_class, streaming: :unary
+			end
+			
+			rpc = interface_class.lookup_rpc(:custom)
+			expect(rpc.request_class).to be == request_class
+			expect(rpc.response_class).to be == response_class
+			expect(rpc.streaming).to be == :unary
+			expect(rpc.streaming?).to be == false
+		end
+		
+		it "unwraps message classes from Streaming wrapper" do
+			request_class = self.request_class
+			response_class = self.response_class
+			
+			interface_class = Class.new(Protocol::GRPC::Interface) do
+				rpc :test, stream(request_class), stream(response_class)
+			end
+			
+			rpc = interface_class.lookup_rpc(:test)
+			
+			# Should unwrap to actual classes, not Streaming instances
+			expect(rpc.request_class).to be == request_class
+			expect(rpc.response_class).to be == response_class
+			expect(rpc.request_class).not.to be_a(Protocol::GRPC::Streaming)
+			expect(rpc.response_class).not.to be_a(Protocol::GRPC::Streaming)
+		end
+		
+		it "can use stream() directly in Interface subclass" do
+			request_class = self.request_class
+			response_class = self.response_class
+			
+			interface_class = Class.new(Protocol::GRPC::Interface) do
+				# Use stream() without Protocol::GRPC prefix
+				rpc :sum, stream(request_class), response_class
+				rpc :fib, request_class, stream(response_class)
+				rpc :chat, stream(request_class), stream(response_class)
+			end
+			
+			sum_rpc = interface_class.lookup_rpc(:sum)
+			expect(sum_rpc.streaming).to be == :client_streaming
+			expect(sum_rpc.request_class).to be == request_class
+			expect(sum_rpc.response_class).to be == response_class
+			
+			fib_rpc = interface_class.lookup_rpc(:fib)
+			expect(fib_rpc.streaming).to be == :server_streaming
+			expect(fib_rpc.request_class).to be == request_class
+			expect(fib_rpc.response_class).to be == response_class
+			
+			chat_rpc = interface_class.lookup_rpc(:chat)
+			expect(chat_rpc.streaming).to be == :bidirectional
+			expect(chat_rpc.request_class).to be == request_class
+			expect(chat_rpc.response_class).to be == response_class
+		end
+	end
 end