async-grpc 0.1.0

data/lib/async/grpc/client.rb

@@ -0,0 +1,351 @@
+# frozen_string_literal: true
+
+# Released under the MIT License.
+# Copyright, 2025, by Samuel Williams.
+
+require "async"
+require "async/http/client"
+require "async/http/endpoint"
+
+require "protocol/http"
+require "protocol/grpc"
+require "protocol/grpc/interface"
+require "protocol/grpc/methods"
+require "protocol/grpc/body/readable_body"
+require "protocol/grpc/body/writable_body"
+require "protocol/grpc/metadata"
+require "protocol/grpc/error"
+require_relative "stub"
+
+module Async
+	module GRPC
+		# Represents a client for making gRPC calls over HTTP/2.
+		class Client < Protocol::HTTP::Middleware
+			ENDPOINT = nil
+			
+			# Connect to the given endpoint, returning the HTTP client.
+			# @parameter endpoint [Async::HTTP::Endpoint] used to connect to the remote system.
+			# @returns [Async::HTTP::Client] the HTTP client.
+			def self.connect(endpoint)
+				HTTP::Client.new(endpoint)
+			end
+			
+			# Create a new client for the given endpoint.
+			# @parameter endpoint [Async::HTTP::Endpoint, String] The endpoint to connect to
+			# @parameter headers [Protocol::HTTP::Headers] Default headers to include with requests
+			# @yields {|client| ...} Optional block - client will be closed after block execution
+			# @returns [Client] The client instance
+			def self.open(endpoint = self::ENDPOINT, headers: Protocol::HTTP::Headers.new, **options)
+				endpoint = Async::HTTP::Endpoint.parse(endpoint) if endpoint.is_a?(String)
+				
+				client = connect(endpoint)
+				
+				grpc_client = new(client, headers: headers, **options)
+				
+				return grpc_client unless block_given?
+				
+				Sync do
+					yield grpc_client
+				ensure
+					grpc_client.close
+				end
+			end
+			
+			# Create a new client with merged headers from a parent client.
+			# @parameter parent [Client] The parent client to inherit headers from
+			# @parameter headers [Hash] Additional headers to merge
+			# @returns [Client] A new client instance with merged headers
+			def self.with(parent, headers: {})
+				merged_headers = parent.headers.merge(headers)
+				
+				new(parent.delegate, headers: merged_headers)
+			end
+			
+			# Initialize a new gRPC client.
+			# @parameter delegate [Async::HTTP::Client] The HTTP client that will handle requests
+			# @parameter headers [Protocol::HTTP::Headers] The default headers that will be supplied with requests
+			def initialize(delegate, headers: Protocol::HTTP::Headers.new)
+				super(delegate)
+				
+				@headers = headers
+			end
+			
+			# @attribute [Protocol::HTTP::Headers] The default headers for requests.
+			attr_reader :headers
+			
+			# Get a string representation of the client.
+			# @returns [String] A string representation including headers
+			def inspect
+				"\#<#{self.class} #{@headers.inspect}>"
+			end
+			
+			# Get a string representation of the client.
+			# @returns [String] A string representation of the client class
+			def to_s
+				"\#<#{self.class}>"
+			end
+			
+			# Create a stub for the given interface.
+			# @parameter interface_class [Class] Interface class (subclass of Protocol::GRPC::Interface)
+			# @parameter service_name [String] Service name (e.g., "hello.Greeter")
+			# @returns [Async::GRPC::Stub] Stub object with methods for each RPC
+			def stub(interface_class, service_name)
+				interface = interface_class.new(service_name)
+				Stub.new(self, interface)
+			end
+			
+			# Call the underlying HTTP client with merged headers.
+			# @parameter request [Protocol::HTTP::Request] The HTTP request
+			# @returns [Protocol::HTTP::Response] The HTTP response
+			def call(request)
+				request.headers = @headers.merge(request.headers)
+				
+				super
+			end
+			
+			# Make a gRPC call.
+			# @parameter service [Protocol::GRPC::Interface] Interface definition
+			# @parameter method [Symbol, String] Method name
+			# @parameter request [Object | Nil] Request message (`Nil` for streaming)
+			# @parameter metadata [Hash] Custom metadata headers
+			# @parameter timeout [Numeric | Nil] Optional timeout in seconds
+			# @parameter encoding [String | Nil] Optional compression encoding
+			# @yields {|input, output| ...} Block for streaming calls
+			# @returns [Object | Protocol::GRPC::Body::ReadableBody] Response message or readable body for streaming
+			# @raises [ArgumentError] If method is unknown or streaming type is invalid
+			# @raises [Protocol::GRPC::Error] If the gRPC call fails
+			def invoke(service, method, request = nil, metadata: {}, timeout: nil, encoding: nil, &block)
+				rpc = service.class.lookup_rpc(method)
+				raise ArgumentError, "Unknown method: #{method}" unless rpc
+				
+				path = service.path(method)
+				headers = Protocol::GRPC::Methods.build_headers(
+					metadata: metadata,
+					timeout: timeout,
+					content_type: "application/grpc+proto"
+				)
+				headers["grpc-encoding"] = encoding if encoding
+				
+				streaming = rpc.streaming
+				request_class = rpc.request_class
+				response_class = rpc.response_class
+				
+				case streaming
+				when :unary
+					unary_call(path, headers, request, request_class, response_class, encoding)
+				when :server_streaming
+					server_streaming_call(path, headers, request, request_class, response_class, encoding, &block)
+				when :client_streaming
+					client_streaming_call(path, headers, request_class, response_class, encoding, &block)
+				when :bidirectional
+					bidirectional_call(path, headers, request_class, response_class, encoding, &block)
+				else
+					raise ArgumentError, "Unknown streaming type: #{streaming}"
+				end
+			end
+			
+		protected
+			
+			# Make a unary gRPC call.
+			# @parameter path [String] The gRPC path
+			# @parameter headers [Protocol::HTTP::Headers] Request headers
+			# @parameter request_message [Object] Request message
+			# @parameter request_class [Class] Request message class
+			# @parameter response_class [Class] Response message class
+			# @parameter encoding [String | Nil] Compression encoding
+			# @returns [Object] Response message
+			# @raises [Protocol::GRPC::Error] If the gRPC call fails
+			def unary_call(path, headers, request_message, request_class, response_class, encoding)
+				body = Protocol::GRPC::Body::WritableBody.new(encoding: encoding, message_class: request_class)
+				body.write(request_message)
+				body.close_write
+				
+				http_request = Protocol::HTTP::Request["POST", path, headers, body]
+				response = call(http_request)
+				
+				begin
+					# Read body first - trailers are only available after body is consumed
+					response_encoding = response.headers["grpc-encoding"]
+					readable_body = Protocol::GRPC::Body::ReadableBody.new(
+						response.body,
+						message_class: response_class,
+						encoding: response_encoding
+					)
+					
+					message = readable_body.read
+					readable_body.close
+					
+					# Check status after reading body (trailers are now available)
+					check_status!(response)
+					
+					message
+				ensure
+					response.close
+				end
+			end
+			
+			# Make a server streaming gRPC call.
+			# @parameter path [String] The gRPC path
+			# @parameter headers [Protocol::HTTP::Headers] Request headers
+			# @parameter request_message [Object] Request message
+			# @parameter request_class [Class] Request message class
+			# @parameter response_class [Class] Response message class
+			# @parameter encoding [String | Nil] Compression encoding
+			# @yields {|message| ...} Block to process each message in the stream
+			# @returns [Protocol::GRPC::Body::ReadableBody] Readable body for streaming messages
+			# @raises [Protocol::GRPC::Error] If the gRPC call fails
+			def server_streaming_call(path, headers, request_message, request_class, response_class, encoding, &block)
+				body = Protocol::GRPC::Body::WritableBody.new(encoding: encoding, message_class: request_class)
+				body.write(request_message)
+				body.close_write
+				
+				http_request = Protocol::HTTP::Request["POST", path, headers, body]
+				response = call(http_request)
+				
+				begin
+					# Set gRPC policy BEFORE reading body so trailers are processed correctly:
+					unless response.headers.policy == Protocol::GRPC::HEADER_POLICY
+						response.headers.policy = Protocol::GRPC::HEADER_POLICY
+					end
+					
+					# Read body first - trailers are only available after body is consumed:
+					response_encoding = response.headers["grpc-encoding"]
+					readable_body = Protocol::GRPC::Body::ReadableBody.new(
+						response.body,
+						message_class: response_class,
+						encoding: response_encoding
+					)
+					
+					return readable_body unless block_given?
+					
+					begin
+						readable_body.each(&block)
+					ensure
+						readable_body.close
+					end
+					
+					# Check status after reading all body chunks (trailers are now available):
+					check_status!(response)
+					
+					readable_body
+				rescue StandardError
+					response.close
+					raise
+				end
+			end
+			
+			# Make a client streaming gRPC call.
+			# @parameter path [String] The gRPC path
+			# @parameter headers [Protocol::HTTP::Headers] Request headers
+			# @parameter request_class [Class] Request message class
+			# @parameter response_class [Class] Response message class
+			# @parameter encoding [String | Nil] Compression encoding
+			# @yields {|output| ...} Block to write messages to the stream
+			# @returns [Object] Response message
+			# @raises [Protocol::GRPC::Error] If the gRPC call fails
+			def client_streaming_call(path, headers, request_class, response_class, encoding, &block)
+				body = Protocol::GRPC::Body::WritableBody.new(encoding: encoding, message_class: request_class)
+				
+				http_request = Protocol::HTTP::Request["POST", path, headers, body]
+				
+				block.call(body) if block_given?
+				body.close_write unless body.closed?
+				
+				response = call(http_request)
+				
+				begin
+					# Read body first - trailers are only available after body is consumed:
+					response_encoding = response.headers["grpc-encoding"]
+					readable_body = Protocol::GRPC::Body::ReadableBody.new(
+						response.body,
+						message_class: response_class,
+						encoding: response_encoding
+					)
+					
+					message = readable_body.read
+					readable_body.close
+					
+					# Check status after reading body (trailers are now available):
+					check_status!(response)
+					
+					message
+				ensure
+					response.close
+				end
+			end
+			
+			# Make a bidirectional streaming gRPC call.
+			# @parameter path [String] The gRPC path
+			# @parameter headers [Protocol::HTTP::Headers] Request headers
+			# @parameter request_class [Class] Request message class
+			# @parameter response_class [Class] Response message class
+			# @parameter encoding [String | Nil] Compression encoding
+			# @yields {|input, output| ...} Block to handle bidirectional streaming
+			# @returns [Protocol::GRPC::Body::ReadableBody] Readable body for streaming messages
+			# @raises [Protocol::GRPC::Error] If the gRPC call fails
+			def bidirectional_call(path, headers, request_class, response_class, encoding, &block)
+				body = Protocol::GRPC::Body::WritableBody.new(
+					encoding: encoding,
+					message_class: request_class
+				)
+				
+				http_request = Protocol::HTTP::Request["POST", path, headers, body]
+				response = call(http_request)
+				
+				begin
+					# Read body first - trailers are only available after body is consumed:
+					response_encoding = response.headers["grpc-encoding"]
+					readable_body = Protocol::GRPC::Body::ReadableBody.new(
+						response.body,
+						message_class: response_class,
+						encoding: response_encoding
+					)
+					
+					return readable_body unless block_given?
+					
+					begin
+						block.call(readable_body, body)
+						body.close_write unless body.closed?
+						
+						# Consume all response chunks to ensure trailers are available:
+						readable_body.each{|_|}
+					ensure
+						readable_body.close
+					end
+					
+					# Check status after reading all body chunks (trailers are now available):
+					check_status!(response)
+					
+					readable_body
+				rescue StandardError
+					response.close
+					raise
+				end
+			end
+			
+			# Check gRPC status and raise appropriate error if not OK.
+			# @parameter response [Protocol::HTTP::Response]
+			# @raises [Protocol::GRPC::Error] If status is not OK
+			def check_status!(response)
+				# Policy should already be set before calling this method:
+				# But ensure it's set just in case
+				unless response.headers.policy == Protocol::GRPC::HEADER_POLICY
+					response.headers.policy = Protocol::GRPC::HEADER_POLICY
+				end
+				
+				status = Protocol::GRPC::Metadata.extract_status(response.headers)
+				
+				# If status is UNKNOWN (not found), default to OK:
+				# This handles cases where trailers aren't available or status wasn't set
+				status = Protocol::GRPC::Status::OK if status == Protocol::GRPC::Status::UNKNOWN
+				
+				return if status == Protocol::GRPC::Status::OK
+				
+				message = Protocol::GRPC::Metadata.extract_message(response.headers)
+				metadata = Protocol::GRPC::Methods.extract_metadata(response.headers)
+				
+				raise Protocol::GRPC::Error.for(status, message, metadata: metadata)
+			end
+		end
+	end
+end

data/lib/async/grpc/dispatcher_middleware.rb

@@ -0,0 +1,113 @@
+# frozen_string_literal: true
+
+# Released under the MIT License.
+# Copyright, 2025, by Samuel Williams.
+
+require "protocol/grpc/middleware"
+require "protocol/grpc/methods"
+require "protocol/grpc/call"
+require "protocol/grpc/body/readable_body"
+require "protocol/grpc/body/writable_body"
+require "protocol/grpc/metadata"
+require "protocol/grpc/error"
+require "protocol/grpc/status"
+
+module Async
+	module GRPC
+		# Represents middleware that dispatches gRPC requests to registered services.
+		# Handles routing based on service name from the request path.
+		#
+		# @example Registering services:
+		#   dispatcher = DispatcherMiddleware.new
+		#   dispatcher.register("hello.Greeter", GreeterService.new(GreeterInterface, "hello.Greeter"))
+		#   dispatcher.register("world.Greeter", WorldService.new(WorldInterface, "world.Greeter"))
+		#
+		#   server = Async::HTTP::Server.for(endpoint, dispatcher)
+		class DispatcherMiddleware < Protocol::GRPC::Middleware
+			# Initialize the dispatcher.
+			# @parameter app [#call | Nil] The next middleware in the chain
+			# @parameter services [Hash] Optional initial services hash (service_name => service_instance)
+			def initialize(app = nil, services: {})
+				super(app)
+				@services = services
+			end
+			
+			# Register a service.
+			# @parameter service_name [String] Service name (e.g., "hello.Greeter")
+			# @parameter service [Async::GRPC::Service] Service instance
+			def register(service_name, service)
+				@services[service_name] = service
+			end
+			
+			protected
+			
+			# Dispatch the request to the appropriate service.
+			# @parameter request [Protocol::HTTP::Request] The HTTP request
+			# @returns [Protocol::HTTP::Response] The HTTP response
+			# @raises [Protocol::GRPC::Error] If service or method is not found
+			def dispatch(request)
+				# Parse service and method from path:
+				service_name, method_name = Protocol::GRPC::Methods.parse_path(request.path)
+				
+				# Find service:
+				service = @services[service_name]
+				unless service
+					raise Protocol::GRPC::Error.new(Protocol::GRPC::Status::UNIMPLEMENTED, "Service not found: #{service_name}")
+				end
+				
+				# Verify service name matches:
+				unless service_name == service.service_name
+					raise Protocol::GRPC::Error.new(Protocol::GRPC::Status::UNIMPLEMENTED, "Service name mismatch: expected #{service.service_name}, got #{service_name}")
+				end
+				
+				# Get RPC descriptions from the service:
+				rpc_descriptor = service.rpc_descriptions[method_name]
+				unless rpc_descriptor
+					raise Protocol::GRPC::Error.new(Protocol::GRPC::Status::UNIMPLEMENTED, "Method not found: #{method_name}")
+				end
+				
+				handler_method = rpc_descriptor[:method]
+				request_class = rpc_descriptor[:request_class]
+				response_class = rpc_descriptor[:response_class]
+				
+				# Verify handler method exists:
+				unless service.respond_to?(handler_method, true)
+					raise Protocol::GRPC::Error.new(Protocol::GRPC::Status::UNIMPLEMENTED, "Handler method not implemented: #{handler_method}")
+				end
+				
+				# Create protocol-level objects for gRPC handling:
+				encoding = request.headers["grpc-encoding"]
+				input = Protocol::GRPC::Body::ReadableBody.new(request.body, message_class: request_class, encoding: encoding)
+				output = Protocol::GRPC::Body::WritableBody.new(message_class: response_class, encoding: encoding)
+				
+				# Create call context:
+				response_headers = Protocol::HTTP::Headers.new([], nil, policy: Protocol::GRPC::HEADER_POLICY)
+				response_headers["content-type"] = "application/grpc+proto"
+				response_headers["grpc-encoding"] = encoding if encoding
+				
+				# Parse deadline from timeout header:
+				timeout_value = request.headers["grpc-timeout"]
+				deadline = if timeout_value
+					timeout_seconds = Protocol::GRPC::Methods.parse_timeout(timeout_value)
+					require "async/deadline"
+					Async::Deadline.start(timeout_seconds) if timeout_seconds
+				end
+				
+				call = Protocol::GRPC::Call.new(request, deadline: deadline)
+				
+				# Call the handler method on the service:
+				service.send(handler_method, input, output, call)
+				
+				# Close output stream:
+				output.close_write unless output.closed?
+				
+				# Mark trailers and add status:
+				response_headers.trailer!
+				Protocol::GRPC::Metadata.add_status_trailer!(response_headers, status: Protocol::GRPC::Status::OK)
+				
+				Protocol::HTTP::Response[200, response_headers, output]
+			end
+		end
+	end
+end
+

data/lib/async/grpc/service.rb

@@ -0,0 +1,93 @@
+# frozen_string_literal: true
+
+# Released under the MIT License.
+# Copyright, 2025, by Samuel Williams.
+
+require "protocol/grpc/interface"
+
+module Async
+	module GRPC
+		# Represents a concrete service implementation that uses an Interface.
+		# Subclass this and implement the RPC methods defined in the interface.
+		# Services are registered with DispatcherMiddleware for routing.
+		#
+		# @example Example service implementation:
+		#   class GreeterInterface < Protocol::GRPC::Interface
+		#     rpc :SayHello, request_class: Hello::HelloRequest, response_class: Hello::HelloReply
+		#     # Optional: explicit method name for edge cases
+		#     rpc :XMLParser, request_class: Hello::ParseRequest, response_class: Hello::ParseReply,
+		#         method: :xml_parser  # Explicit method name (otherwise would be :xmlparser)
+		#   end
+		#
+		#   class GreeterService < Async::GRPC::Service
+		#     def say_hello(input, output, call)
+		#       request = input.read
+		#       reply = Hello::HelloReply.new(message: "Hello, #{request.name}!")
+		#       output.write(reply)
+		#     end
+		#
+		#     def xml_parser(input, output, call)
+		#       # Implementation using explicit method name
+		#     end
+		#   end
+		#
+		#   # Register with dispatcher:
+		#   dispatcher = DispatcherMiddleware.new
+		#   dispatcher.register("hello.Greeter", GreeterService.new(GreeterInterface, "hello.Greeter"))
+		#   server = Async::HTTP::Server.for(endpoint, dispatcher)
+		class Service
+			# Initialize a new service instance.
+			# @parameter interface_class [Class] The interface class (subclass of Protocol::GRPC::Interface)
+			# @parameter service_name [String] The service name (e.g., "hello.Greeter")
+			def initialize(interface_class, service_name)
+				@interface_class = interface_class
+				@service_name = service_name
+			end
+			
+			# @attribute [Class] The interface class.
+			attr_reader :interface_class
+			
+			# @attribute [String] The service name.
+			attr_reader :service_name
+			
+			# Get RPC descriptions from the interface class.
+			# Converts Interface RPC definitions (PascalCase) to rpc_descriptions format.
+			# Maps gRPC method names (PascalCase) to Ruby method names (snake_case).
+			# @returns [Hash] RPC descriptions hash keyed by PascalCase method name
+			def rpc_descriptions
+				descriptions = {}
+				
+				@interface_class.rpcs.each do |pascal_case_name, rpc|
+					# Use explicit method name if provided, otherwise convert PascalCase to snake_case:
+					ruby_method_name = if rpc.method
+						rpc.method
+					else
+						snake_case_name = pascal_case_to_snake_case(pascal_case_name.to_s)
+						snake_case_name.to_sym
+					end
+					
+					descriptions[pascal_case_name.to_s] = {
+						method: ruby_method_name,
+						request_class: rpc.request_class,
+						response_class: rpc.response_class,
+						streaming: rpc.streaming
+					}
+				end
+				
+				descriptions
+			end
+			
+		private
+			
+			# Convert PascalCase to snake_case.
+			# @parameter pascal_case [String] PascalCase string (e.g., "SayHello")
+			# @returns [String] snake_case string (e.g., "say_hello")
+			def pascal_case_to_snake_case(pascal_case)
+				pascal_case
+					.gsub(/([A-Z]+)([A-Z][a-z])/, '\1_\2')  # Insert underscore before capital letters followed by lowercase
+					.gsub(/([a-z\d])([A-Z])/, '\1_\2')      # Insert underscore between lowercase/digit and uppercase
+					.downcase
+			end
+		end
+	end
+end

data/lib/async/grpc/stub.rb

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+# Released under the MIT License.
+# Copyright, 2025, by Samuel Williams.
+
+require "protocol/grpc/interface"
+
+module Async
+	module GRPC
+		# Represents a client stub that provides method-based access to RPC calls.
+		# Created by calling {Client#stub}.
+		class Stub
+			# Initialize a new stub instance.
+			# @parameter client [Async::GRPC::Client] The gRPC client
+			# @parameter interface [Protocol::GRPC::Interface] The interface instance
+			def initialize(client, interface)
+				@client = client
+				@interface = interface
+				@interface_class = interface.class
+				# Cache RPCs indexed by snake_case method name (default)
+				@rpcs_by_method = {}
+				
+				@interface_class.rpcs.each do |pascal_case_name, rpc|
+					# rpc.method is always set (either explicit or auto-converted from PascalCase)
+					snake_case_method = rpc.method
+					
+					# Index by snake_case method name, storing RPC and PascalCase name for path building
+					@rpcs_by_method[snake_case_method] = [rpc, pascal_case_name]
+				end
+			end
+			
+			# @attribute [Protocol::GRPC::Interface] The interface instance.
+			attr_reader :interface
+			
+			# Dynamically handle method calls for RPC methods.
+			# Uses snake_case method names (Ruby convention).
+			# @parameter method_name [Symbol] The method name to call (snake_case)
+			# @parameter args [Array] Positional arguments (first is the request message)
+			# @parameter options [Hash] Keyword arguments (metadata, timeout, encoding)
+			# @yields {|input, output| ...} Block for streaming calls
+			# @returns [Object | Protocol::GRPC::Body::ReadableBody] Response message or readable body
+			# @raises [NoMethodError] If the method is not found
+			def method_missing(method_name, *args, **options, &block)
+				rpc, interface_method_name = lookup_rpc(method_name)
+				
+				if rpc
+					# Extract request from args (first positional argument):
+					request = args.first
+					
+					# Extract metadata, timeout, encoding from options:
+					metadata = options.delete(:metadata) || {}
+					timeout = options.delete(:timeout)
+					encoding = options.delete(:encoding)
+					
+					# Delegate to client.invoke with PascalCase method name (for interface lookup):
+					@client.invoke(@interface, interface_method_name, request, metadata: metadata, timeout: timeout, encoding: encoding,
+						&block)
+				else
+					super
+				end
+			end
+			
+			# Check if the stub responds to the given method.
+			# @parameter method_name [Symbol] The method name to check
+			# @parameter include_private [Boolean] Whether to include private methods
+			# @returns [Boolean] `true` if the method exists, `false` otherwise
+			def respond_to_missing?(method_name, include_private = false)
+				rpc, _ = lookup_rpc(method_name)
+				return true if rpc
+				
+				super
+			end
+			
+		private
+			
+			# Look up RPC definition for a method name.
+			# @parameter method_name [Symbol] The method name to look up (snake_case)
+			# @returns [Array(Protocol::GRPC::RPC, Symbol) | Array(Nil, Nil)] RPC definition and PascalCase method name, or nil if not found
+			def lookup_rpc(method_name)
+				if @rpcs_by_method.key?(method_name)
+					rpc, pascal_case_name = @rpcs_by_method[method_name]
+					return [rpc, pascal_case_name]
+				end
+				
+				[nil, nil]
+			end
+		end
+	end
+end

data/lib/async/grpc/version.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+# Released under the MIT License.
+# Copyright, 2025, by Samuel Williams.
+
+# @namespace
+module Async
+	# @namespace
+	module GRPC
+		VERSION = "0.1.0"
+	end
+end

data/lib/async/grpc.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+# Released under the MIT License.
+# Copyright, 2025, by Samuel Williams.
+
+require_relative "grpc/version"
+require_relative "grpc/client"
+require_relative "grpc/service"
+require_relative "grpc/stub"
+require_relative "grpc/dispatcher_middleware"
+
+module Async
+	module GRPC
+	end
+end

data/license.md

@@ -0,0 +1,21 @@
+# MIT License
+
+Copyright, 2025, by Samuel Williams.  
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.