async-grpc 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: a4796002440be1be16d777561582938e9ba8651636a7ebdc14e5f2ec5500e317
+  data.tar.gz: 47658a764095cc220dc087f9c12199cbfd78490c32f25949f4c93d94790525bc
+SHA512:
+  metadata.gz: e2ec6aff5358f4385d8d99db9ddcdfb2bf0987a50fbf2eefa12baebbbbebeeb6c206244fc57f7d73676be899e2d373975111f325cc147603b9b73ba3d0767a74
+  data.tar.gz: d1b3823eb2ce13f7c2ed01e8cccefb36bb7a17500f25b260ffa7227e0bb0d3c77c06cf05f5ae7b6e0e963ab408d9ba398200da3f6bec0d3e23fb3647dd4977d1

data/context/getting-started.md

@@ -0,0 +1,174 @@
+# Getting Started
+
+This guide explains how to get started with `Async::GRPC` for building gRPC clients and servers.
+
+## Installation
+
+Add the gem to your project:
+
+~~~ bash
+$ bundle add async-grpc
+~~~
+
+You'll also need `protocol-grpc` and `async-http`:
+
+~~~ bash
+$ bundle add protocol-grpc async-http
+~~~
+
+## Core Concepts
+
+`async-grpc` provides:
+
+  - {ruby Async::GRPC::Client} - An asynchronous gRPC client that wraps `Async::HTTP::Client`.
+  - {ruby Async::GRPC::Stub} - A method-based stub for making RPC calls.
+  - {ruby Async::GRPC::Service} - A concrete service implementation that uses a `Protocol::GRPC::Interface`.
+  - {ruby Async::GRPC::DispatcherMiddleware} - Middleware that routes requests to registered services.
+
+## Client Usage
+
+### Creating a Client
+
+``` ruby
+require "async/grpc"
+require "async/http/endpoint"
+
+endpoint = Async::HTTP::Endpoint.parse("https://grpc.example.com")
+http_client = Async::HTTP::Client.new(endpoint)
+client = Async::GRPC::Client.new(http_client)
+```
+
+### Using a Stub
+
+Create a stub from an interface definition:
+
+``` ruby
+# Define the interface
+class GreeterInterface < Protocol::GRPC::Interface
+	rpc :SayHello, request_class: Hello::HelloRequest, response_class: Hello::HelloReply
+end
+
+# Create a stub
+stub = client.stub(GreeterInterface, "hello.Greeter")
+
+# Make RPC calls (accepts both snake_case and PascalCase)
+response = stub.say_hello(Hello::HelloRequest.new(name: "World"))
+# or
+response = stub.SayHello(Hello::HelloRequest.new(name: "World"))
+```
+
+### Streaming RPCs
+
+``` ruby
+# Server streaming
+stub.server_streaming_call(request) do |response|
+	puts response.value
+end
+
+# Client streaming
+stub.client_streaming_call do |output|
+	output.write(request1)
+	output.write(request2)
+end
+
+# Bidirectional streaming
+stub.bidirectional_streaming do |input, output|
+	input.each do |request|
+		output.write(process(request))
+	end
+end
+```
+
+## Server Usage
+
+### Defining a Service
+
+``` ruby
+require "async/grpc/service"
+
+# Define the interface
+class GreeterInterface < Protocol::GRPC::Interface
+	rpc :SayHello, request_class: Hello::HelloRequest, response_class: Hello::HelloReply
+end
+
+# Implement the service
+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
+end
+```
+
+### Registering Services
+
+``` ruby
+require "async/grpc/dispatcher_middleware"
+
+dispatcher = Async::GRPC::DispatcherMiddleware.new
+
+service = GreeterService.new(GreeterInterface, "hello.Greeter")
+dispatcher.register("hello.Greeter", service)
+```
+
+### Running a Server
+
+``` ruby
+require "async/http/server"
+require "async/http/endpoint"
+
+endpoint = Async::HTTP::Endpoint.parse("http://localhost:50051")
+server = Async::HTTP::Server.for(endpoint, dispatcher)
+
+Async do
+	server.run
+end
+```
+
+## Complete Example
+
+``` ruby
+require "async"
+require "async/grpc"
+require "async/http/server"
+require "async/http/endpoint"
+
+# Define interface
+class GreeterInterface < Protocol::GRPC::Interface
+	rpc :SayHello, request_class: Hello::HelloRequest, response_class: Hello::HelloReply
+end
+
+# Implement service
+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
+end
+
+Async do
+		# Setup server
+	endpoint = Async::HTTP::Endpoint.parse("http://localhost:50051")
+	dispatcher = Async::GRPC::DispatcherMiddleware.new
+	dispatcher.register("hello.Greeter", GreeterService.new(GreeterInterface, "hello.Greeter"))
+	server = Async::HTTP::Server.for(endpoint, dispatcher)
+	
+		# Setup client
+	client_endpoint = Async::HTTP::Endpoint.parse("http://localhost:50051")
+	http_client = Async::HTTP::Client.new(client_endpoint)
+	client = Async::GRPC::Client.new(http_client)
+	stub = client.stub(GreeterInterface, "hello.Greeter")
+	
+		# Make a call
+	request = Hello::HelloRequest.new(name: "World")
+	response = stub.say_hello(request)
+	puts response.message  # => "Hello, World!"
+	
+	server.run
+end
+```
+
+
+

data/context/index.yaml

@@ -0,0 +1,12 @@
+# Automatically generated context index for Utopia::Project guides.
+# Do not edit then files in this directory directly, instead edit the guides and then run `bake utopia:project:agent:context:update`.
+---
+description: Client and server implementation for gRPC using Async.
+metadata:
+  documentation_uri: https://socketry.github.io/async-grpc/
+  source_code_uri: https://github.com/socketry/async-grpc.git
+files:
+- path: getting-started.md
+  title: Getting Started
+  description: This guide explains how to get started with `Async::GRPC` for building
+    gRPC clients and servers.