connectrpc-on-rails 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: bf9035d7ed20c0a0fa34ca686bfebec9849f32a2826905050af3912ffd5ec8f1
+  data.tar.gz: 5458391b5e2eceb1238a7caaf27b5b92d1f16857cbccb83d882925adae706297
+SHA512:
+  metadata.gz: a790bb7f79b68215639bc012e66c26472505454cad2e30ec171bf346eb1163b700c3627135bb67d4fe5013dffd1bb41fa65cebce06f1dfcff82ee6b75589c113
+  data.tar.gz: 5ed934edc8ce7a0cc60a3b93d5299a05efc25c6fe11589c9180bbc1c03b9f0c0b694d1f7781483193172ec6906fd68ca1175ad33737143c85326448afdecb6f7

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Jim Myhrberg
+
+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.

data/README.md

@@ -0,0 +1,256 @@
+# connectrpc-on-rails
+
+Optional native Rails controller execution for the experimental, unofficial
+ConnectRPC unary Ruby gem. The core gem remains independent of Rails and has
+zero runtime dependencies. This adapter reuses its Server invoker and the
+optional [connectrpc-rack](../connectrpc-rack/README.md) translation. It does not add another protocol implementation.
+
+See the [supported 0.x contract](../../docs/support.md) for the target support
+profile, matched package versions, compatibility policy and adoption gates.
+
+## Use a controller
+
+Add `connectrpc-on-rails` and your chosen protobuf binding dependency to your
+application Gemfile. Runtime dependencies are `connectrpc ~> 0.1.0`,
+`connectrpc-rack ~> 0.1.0`, and `actionpack >= 8.0.5.1, < 8.2`.
+The Rack package supplies the `rack >= 3.2.7, < 4` requirement. The application
+chooses its controller base, binding, authentication, and security policy.
+Requiring `connectrpc/on_rails` loads neither `ActionController::Base` nor
+`ActionController::API`, and does not load Google protobuf. `Bundler.require`
+loads the same entry point through `connectrpc-on-rails`.
+
+Generate official protobuf messages and Connect service glue as described in
+the [root README](../../README.md). Keep generated files outside Zeitwerk's
+managed paths. For example, use `generated/rpc`, add that directory to
+`$LOAD_PATH`, and require `echo_connect` from an initializer. If placing generated
+files under `lib`, explicitly ignore their directory in the application's
+Zeitwerk configuration before eager loading. Generated filenames do not match
+the constants they define, generated glue requires its message files, and it
+intentionally rejects `load`/redefinition. These files are non-reloadable.
+Ordinary application controllers retain normal Rails reload behavior.
+
+For the repository's generated `Example::V1::EchoService` fixture:
+
+```ruby
+require "connectrpc/on_rails"
+require "connectrpc/bindings/google_protobuf"
+require "echo_connect"
+
+class EchoController < ApplicationController
+  include ConnectRPC::OnRails::Controller
+
+  private
+
+  def connect_service = Example::V1::EchoService::SERVICE
+  def connect_binding = ConnectRPC::Bindings::GoogleProtobuf.new
+  def connect_handlers
+    Example::V1::EchoService.handlers(echo: method(:rpc_echo), fail: method(:rpc_fail))
+  end
+  def connect_limits = { request_limit: 1_048_576 }
+
+  def rpc_echo(message, context)
+    context.response_metadata.add("x-worker", "rails")
+    context.response_trailers.add("x-finished", "yes")
+    message
+  end
+
+  def rpc_fail(_message, _context)
+    raise ConnectRPC::Error.new(:invalid_argument, "safe application message")
+  end
+end
+```
+
+Use normal named controller routing, optionally under a literal scope:
+
+```ruby
+scope "/rpc" do
+  match "/example.v1.EchoService(/*rpc)", to: "echo#connect", via: :all, format: false
+end
+```
+
+`via: :all` lets core return the protocol's unsupported-verb response.
+`format: false` preserves dots in service names. Dynamic scope segments are
+not supported. Route/service mismatches raise a configuration error.
+The adapter strips only the matched route's literal prefix. Unknown RPC names,
+deeper suffixes, method case and raw escapes reach core unchanged after that
+boundary. Rails itself normalizes duplicate/trailing slashes and escape case
+before controller dispatch, so path acceptance differs from a direct Rack mount.
+
+Only `connect` is an action supplied by the concern. Keep the three required
+configuration hooks and typed handlers private, using prefixed handler names to
+avoid controller/Kernel method collisions. `connect_limits` is optional and
+accepts core `request_limit:`, `response_limit:`, `request_wire_limit:`,
+`response_wire_limit:`, `get_query_limit:` and `encoding:` keywords; omitted options
+use core's 4 MiB defaults. Private `connect_request`, `connect_context`, and
+`connect_method` expose the same typed objects to callbacks and handlers.
+Handlers return typed messages. There is no render helper or routing DSL.
+
+## Lifecycle and errors
+
+Core negotiates, validates deadlines and bounds, reads, and decodes before
+running native Rails callbacks. Authentication callbacks therefore run after
+up to 4 MiB of input has been decoded by default. Preflight failures do not run
+controller callbacks or emit `process_action.action_controller` events.
+Callbacks, `rescue_from`, around-action cleanup and instrumentation use Rails'
+real `process_action` chain. Native completion occurs before core serializes
+the typed result. Configuration, handlers, server and context are evaluated
+fresh for each request. Synchronize any application-owned shared state.
+
+Raise `ConnectRPC::Error` to reject a request or map an application exception.
+Its deliberate code, safe message, typed details, metadata and trailers survive.
+If the application has a catch-all rescue, declare a reraising handler after
+it because native Rails rescue precedence favors later declarations:
+
+```ruby
+rescue_from StandardError, with: :handle_application_error
+rescue_from ConnectRPC::Error do |error|
+  raise error
+end
+```
+
+Raw native render/head halts and exceptions covered by Rails'
+`rescue_responses` use only the unambiguous inverse of Connect HTTP statuses:
+401/403/404/429/499/501/503/504 become unauthenticated/permission_denied/
+not_found/resource_exhausted/canceled/unimplemented/unavailable/
+deadline_exceeded. Messages are generic. Ambiguous 400/409/500, redirects,
+unmapped statuses, and success without a typed result become `internal`.
+A non-200 native halt after the handler also prevents typed success. Raw Rails
+bodies and exception messages never become protocol error messages.
+Exceptions explicitly registered in Rails' `rescue_responses` remain expected
+outcomes and do not produce adapter error reports or exception logs. Unexpected
+exceptions are logged with their original backtraces and reported through
+`Rails.error` before safe core normalization. Request preparation uses the same
+classification, including application overrides to `rescue_responses`.
+
+Controller instrumentation describes controller execution: a deliberate Connect
+exception can appear as a Rails 500, while successful controller execution can
+precede a core encode or response-limit failure. Deadlines remain cooperative;
+they cannot interrupt arbitrary application code or blocked synchronous reads.
+Warden/Devise throws and failure-app responses remain host-owned non-Connect
+responses unless the application explicitly adapts them.
+
+## Request and security policy
+
+During Connect execution, Rails receives an empty request-local indifferent body
+parameter cache and an explicit JSON format. This prevents ParamsWrapper and
+instrumentation from rereading ProtoJSON scalar/array/object roots or parsing
+malformed Accept headers. Use typed `connect_request` for message fields;
+query and route parameters remain accessible by string and symbol. Ordinary
+non-Connect actions retain normal body parsing and format negotiation.
+
+The adapter does not skip CSRF protection, disable sessions, or alter cookie
+policy. A dedicated API controller suits token-authenticated RPC. Base
+controllers use Rails' native safe-verb policy: GET does not require a CSRF
+token; POST retains its configured token/session checks. The application must
+explicitly route desired GET calls and preserve authentication/authorization. An
+application may choose a narrowly scoped exemption according to its security
+model; inclusion alone grants none.
+
+Final core status, wire content type and emitted headers replace the interim
+Rails representation. Stale content-length, content-encoding, ETag,
+Last-Modified and Location are removed. Other host headers, default security
+headers, CSP, authentication headers and cookies survive; repeated Rack 3
+values remain arrays. Downstream Rails/Rack middleware retains its normal
+ownership of request ids, ETags, content length and other final host behavior.
+
+## Verification and tested combinations
+
+The target supported Rails profile is 8.1. Rails 8.0 remains compatibility
+evidence outside that profile. The tested combinations use Linux x64 and
+Bundler 4.0.23:
+
+| Rails | Ruby | Target profile status |
+| --- | --- | --- |
+| 8.1.4 | 3.4.12 and 4.0.9 | Supported framework profile |
+| 8.0.5.1 | 3.4.12 | Compatibility evidence only |
+
+These rows do not promise every framework/runtime combination. As checked on
+2026-11-02, Rails'
+[maintenance policy](https://rubyonrails.org/maintenance) lists security support
+ending 2026-11-07 for 8.0 and 2027-10-10 for 8.1. The 8.0 compatibility lane
+is not a promise to extend upstream maintenance.
+
+From the repository root:
+
+```sh
+mise tasks
+RAILS_LANE=8.0 mise run test:rails
+RAILS_LANE=8.1 mise run verify:rails
+MISE_RUBY_VERSION=4.0.9 RAILS_LANE=8.1 mise run test:rails
+mise run generation:check:rails
+mise run check
+mise run verify
+```
+
+`setup:rails`, `test:rails`, `generation:check:rails`, `build:rails`,
+`check:package:rails`, and `verify:rails` select `RAILS_LANE=8.1` by default.
+Tests accept RSpec paths/options relative to this adapter directory.
+Actual Appraisal 2.5.0 runs under the selected frozen lane bundle, with no extra
+base lock. `BUNDLE_COOLDOWN=7` applies to every adapter bundle process; the plain
+Gemfile source is necessary because Appraisal cannot parse source keywords.
+Pinned Bundler must exist before Appraisal can run, preventing its legacy
+installer fallback. Never use `appraisal install` in CI. Generation is checked
+in a temporary relative-layout copy, without rewriting tracked files.
+
+Both lane locks include checksums and `ruby`/`x86_64-linux` platforms. Native
+variants recorded by Bundler remain checksum-locked. New resolved artifacts
+require a primary registry release-age and archive SHA256 audit. Runtime cache
+uses root `vendor/bundle` by ABI; adapter artifacts and coverage live under
+`vendor/rails`. SimpleCov starts before adapter requires and includes every
+adapter library file, independently of core coverage.
+
+`check:package:rails` builds all three core/Rack/Rails archives, checks exact manifests and metadata,
+and installs them with conventional offline dependency resolution into fresh
+GEM_HOME/GEM_PATH outside the checkout. Installed generated clients perform
+binary/JSON success and structured error calls through a real Rails application
+and Rack::Lint, loading integration code only from the installed archive.
+See [development](../../docs/development.md) for the separate core protocol,
+generation, Go interoperability and official conformance evidence.
+
+## Status and licensing
+
+Experimental and not production ready. Streaming, native gRPC and production
+hosting are outside this adapter. Explicit binary/text unary gRPC-Web uses the
+private hooks described below.
+Original project work is [MIT licensed](LICENSE), copyright 2026 Jim Myhrberg.
+Both gem archives include the complete license and pin `allowed_push_host` to
+`https://rubygems.org`; only the [release workflow](../../docs/releasing.md)
+publishes them. Verification authorizes no publication.
+
+
+To enable unary gzip, return `encoding: :gzip` from the private `connect_limits`
+hook. Core validates wire length, inflates under the decoded request limit, and
+decodes before callbacks and native instrumentation. JSON scalar bodies still
+bypass Rails body-parameter parsing. Negotiated success responses are compressed
+after native execution; errors remain identity. A compression/size failure after
+execution does not rerun callbacks, and native process-action instrumentation can
+record 200 before core replaces the response with its final error. Wire limits
+default to the corresponding message limits; gzip framing overhead must fit too.
+
+## RPC observation
+
+Configure `instrumentation:` on the core Client/Server to enable the fixed
+neutral per-call lifecycle or the optional [OpenTelemetry adapter](../connectrpc-otel/README.md).
+Native controllers override private `connect_instrumentation` (default nil),
+separately from `connect_limits`. Escaping original failures are captured before
+reporting/normalization; successfully handled `rescue_from` exceptions are not
+automatically failures. Configuration before Server construction is outside it.
+
+## Static signatures
+
+This package owns `sig/` and its discovery manifest. Add
+`library "connectrpc-on-rails"` to a strict Steep target with this gem installed.
+See the [RBS guide](../../docs/rbs.md) for supported APIs, extension contracts,
+partial records, runtime validation and framework-signature limits.
+`mise run rbs:check` checks application callers for this package; strict core
+source checking is a separate target from backend implementation checking.
+
+The finite upstream compatibility signatures in `rbs/action_controller_8` are explicit
+opt-ins, separate from normal gem discovery. See the [RBS guide](../../docs/rbs.md#opt-in-framework-compatibility)
+for tested versions, supported framework forms and how to avoid duplicate
+application-owned declarations.
+
+## gRPC-Web
+
+Private connect_protocol, connect_status_codec and connect_cors hooks enable binary/text unary gRPC-Web through the real controller invoker. POST/OPTIONS routes are explicit; auth, callbacks, cookies, security headers and Rails CSRF/origin controls remain active.
+See the [Web guide](../../docs/grpc-web.md) for protocol, CORS, bounds and completion rules.

data/lib/connectrpc/on_rails/controller.rb

@@ -0,0 +1,137 @@
+# frozen_string_literal: true
+
+module ConnectRPC
+  module OnRails
+    module Controller # rubocop:disable Metrics/ModuleLength
+      extend ActiveSupport::Concern
+
+      # Only this method is a Rails action. The generated handler map stays private.
+      def connect
+        handler = @connect_handlers[connect_method.path]
+        raise Error.new(:unimplemented, "Unknown method") unless handler
+
+        @connect_result = handler.call(connect_request, connect_context)
+        @connect_result_set = true
+        self.response_body = ""
+      end
+
+      private
+
+      attr_reader :connect_request, :connect_context, :connect_method
+
+      def connect_service = raise NotImplementedError, "Implement private connect_service"
+      def connect_binding = raise NotImplementedError, "Implement private connect_binding"
+      def connect_handlers = raise NotImplementedError, "Implement private connect_handlers"
+      def connect_limits = {}
+      def connect_instrumentation = nil
+      def connect_protocol = :connect
+      def connect_status_codec = nil
+      def connect_cors = nil
+
+      def process_action(name, ...)
+        return super unless name.to_s == "connect"
+
+        @connect_handlers = connect_handlers
+        connect_dispatch do |rpc_method, message, context|
+          @connect_method = rpc_method
+          @connect_request = message
+          @connect_context = context
+          connect_run_lifecycle { super(name, ...) }
+        end
+      end
+
+      def connect_dispatch(&invoker)
+        service = connect_service
+        env = connect_env(service)
+        server = Server.new(services: [service], binding: connect_binding, handlers: @connect_handlers,
+                            invoker: invoker, instrumentation: connect_instrumentation,
+                            protocol: connect_protocol, status_codec: connect_status_codec, cors: connect_cors,
+                            **connect_limits)
+        ConnectRPC::Rack.new(server: server).__send__(:transfer_response, env) do |result, cors_owned|
+          connect_apply_response(result, cors_owned: cors_owned)
+        end
+      end
+
+      def connect_env(service)
+        prefix = connect_route_prefix(service)
+        raw_path = request.get_header("PATH_INFO")
+        boundary = "#{prefix}/#{service.name}"
+        unless raw_path == boundary || raw_path.start_with?("#{boundary}/")
+          raise ArgumentError, "Connect route does not match the configured service"
+        end
+
+        request.env.merge("PATH_INFO" => raw_path.delete_prefix(prefix))
+      end
+
+      def connect_route_prefix(service)
+        # Use the matched route's literal prefix, never decoded wildcard parameters.
+        pattern = request.route_uri_pattern.to_s
+        match = %r{\A([^:*()]*)/#{Regexp.escape(service.name)}(?=/|\(|\z)}.match(pattern)
+        raise ArgumentError, "Connect route must name the configured service after a literal scope" unless match
+
+        match[1]
+      end
+
+      def connect_prepare_request
+        request.request_parameters = ActiveSupport::HashWithIndifferentAccess.new
+        request.formats = [:json]
+      end
+
+      def connect_run_lifecycle # rubocop:disable Metrics/AbcSize
+        connect_prepare_request
+        yield
+        raise connect_status_error(response.status) unless @connect_result_set && response.status == 200
+
+        @connect_result
+      rescue Error
+        raise
+      rescue StandardError => e
+        connect_context.record_failure(e)
+        connect_report(e)
+        raise connect_status_error(ActionDispatch::ExceptionWrapper.status_code_for_exception(e.class.name))
+      end
+
+      def connect_report(error)
+        return if ActionDispatch::ExceptionWrapper.rescue_responses.key?(error.class.name)
+
+        logger&.error { "[connectrpc.rails] #{error.full_message(highlight: false)}" }
+        return unless defined?(::Rails) && ::Rails.respond_to?(:error)
+
+        ::Rails.error.report(error, handled: false, source: "connectrpc.rails")
+      end
+
+      def connect_status_error(status)
+        # HTTP_FALLBACK is a client proxy mapping and is deliberately unsuitable here.
+        codes = Error::HTTP_STATUS.select { |_code, value| value == status }.keys
+        code = codes.one? ? codes.first : "internal"
+        Error.new(code, code == "internal" ? "Internal error" : code.tr("_", " ").capitalize)
+      end
+
+      def connect_apply_response(result, cors_owned:) # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity
+        status, headers, body = result
+        if cors_owned && response.headers.any? do |key, values|
+             key.start_with?("access-control-") && Array(values) != headers[key]
+           end
+          raise Error.new(:internal, "Conflicting application CORS policy")
+        end
+
+        %w[content-length content-encoding etag last-modified location].each { |key| response.delete_header(key) }
+        self.status = status
+        headers.each do |key, values|
+          values = connect_vary_header(values) if key == "vary"
+          # Rails parses Content-Type as a scalar. Repeated metadata remains Rack 3 arrays.
+          response.set_header(key, key == "content-type" ? values.fetch(0) : values)
+        end
+        self.response_body = body
+      end
+
+      def connect_vary_header(values)
+        native = Array(response.get_header("vary")).flat_map { |value| value.split(",").map(&:strip) }
+        return native if native.include?("*")
+
+        incoming = values.flat_map { |value| value.split(",").map(&:strip) }
+        (native + incoming).uniq(&:downcase)
+      end
+    end
+  end
+end

data/lib/connectrpc/on_rails/version.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module ConnectRPC
+  module OnRails
+    VERSION = "0.1.0" # x-release-please-version
+  end
+end

data/lib/connectrpc/on_rails.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+require "action_controller"
+require_relative "on_rails/version"
+require "connectrpc/rack"
+require_relative "on_rails/controller"

data/lib/connectrpc-on-rails.rb

@@ -0,0 +1,3 @@
+# frozen_string_literal: true
+
+require "connectrpc/on_rails"

data/rbs/action_controller_8/controller.rbs

@@ -0,0 +1,11 @@
+# Opt in only when the application has no Action Controller signatures.
+# Tested with actionpack 8.0.5.1 and 8.1.4. This is a nominal inheritance seam
+# and the named callback form, not a declaration of the complete Rails API.
+module ActionController
+  class API
+    def self.before_action: (*Symbol) -> void
+  end
+  class Base
+    def self.before_action: (*Symbol) -> void
+  end
+end

data/sig/connectrpc-on-rails.rbs

@@ -0,0 +1,22 @@
+module ConnectRPC
+  module OnRails
+    VERSION: String
+    module Controller
+      type limits = { ?request_limit: Integer, ?response_limit: Integer, ?request_wire_limit: Integer, ?response_wire_limit: Integer, ?encoding: :identity | :gzip, ?get_query_limit: Integer?, ?grpc_status_wire_limit: Integer, ?grpc_status_limit: Integer }
+      def connect: () -> String
+      private
+      def connect_service: () -> Service
+      def connect_binding: () -> _Binding
+      def connect_handlers: () -> Hash[String, ^(untyped, Context) -> untyped | _Handler[untyped, untyped]]
+      def connect_limits: () -> limits
+      def connect_protocol: () -> server_protocol_selection
+      def connect_status_codec: () -> _GRPCStatusCodec?
+      def connect_cors: () -> GRPCWebCORS?
+      def connect_instrumentation: () -> Instrumentation?
+      # Outside active decoded execution these readers have no established value.
+      attr_reader connect_request: Object?
+      attr_reader connect_context: Context?
+      attr_reader connect_method: Method[untyped, untyped]?
+    end
+  end
+end

data/sig/manifest.yaml

@@ -0,0 +1,3 @@
+dependencies:
+  - name: connectrpc
+  - name: connectrpc-rack

metadata

@@ -0,0 +1,99 @@
+--- !ruby/object:Gem::Specification
+name: connectrpc-on-rails
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- jimeh
+bindir: bin
+cert_chain: []
+date: 2026-11-15 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: actionpack
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 8.0.5.1
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '8.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 8.0.5.1
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '8.2'
+- !ruby/object:Gem::Dependency
+  name: connectrpc
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.1.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.1.0
+- !ruby/object:Gem::Dependency
+  name: connectrpc-rack
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.1.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.1.0
+description: Optional, experimental Rails lifecycle integration for the unofficial
+  ConnectRPC Ruby gem.
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE
+- README.md
+- lib/connectrpc-on-rails.rb
+- lib/connectrpc/on_rails.rb
+- lib/connectrpc/on_rails/controller.rb
+- lib/connectrpc/on_rails/version.rb
+- rbs/action_controller_8/controller.rbs
+- sig/connectrpc-on-rails.rbs
+- sig/manifest.yaml
+homepage: https://github.com/jimeh/connectrpc-ruby
+licenses:
+- MIT
+metadata:
+  allowed_push_host: https://rubygems.org
+  rubygems_mfa_required: 'true'
+  source_code_uri: https://github.com/jimeh/connectrpc-ruby
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '3.4'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.6.9
+specification_version: 4
+summary: Native Rails controller execution for Connect unary RPCs
+test_files: []