connect-ruby 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 86231e5f8dc50ff0230816ebc5e21b1d3dd6edddb646e85117f62621501dda83
+  data.tar.gz: 31e30adf092732f7e667bb936a3bcad172be1d107a89cb0261adb4ebe962f94c
+SHA512:
+  metadata.gz: f75f16cb3bf278b6b8ccbd4f2ecf2c7464cc77b75b55bae48180bc441d272ed87d8e0e12054fc8460a621fa1c65153700c3fa9deeee449ceab24a54949ad6bc8
+  data.tar.gz: f2f201416fb3ecd402bbc516901259e12daa577162909ca07529371da7be48dc6f68614767beac931c901c138220f14cf1e158dbf06519eb2a1bc509c707f299

data/Gemfile

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+source "https://rubygems.org"
+
+# Specify your gem's dependencies in connect.gemspec
+gemspec
+
+gem "rake", "~> 13.0"
+
+gem "rspec", "~> 3.12"
+
+gem "vcr", "~> 6.2", require: false
+
+gem "webmock", "~> 3.18", require: false
+
+gem "rubocop", "~> 1.54", require: false
+gem "rubocop-rake", "~> 0.6.0", require: false
+gem "rubocop-rspec", "~> 2.22", require: false
+gem "rubocop-shopify", "~> 2.14", require: false
+
+gem "simplecov", "~> 0.22.0", require: false

data/Gemfile.lock

@@ -0,0 +1,101 @@
+PATH
+  remote: .
+  specs:
+    connect-ruby (0.1.0)
+      google-protobuf (~> 3.23)
+      zeitwerk (~> 2.6)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    addressable (2.8.4)
+      public_suffix (>= 2.0.2, < 6.0)
+    ast (2.4.2)
+    crack (0.4.5)
+      rexml
+    diff-lcs (1.5.0)
+    docile (1.4.0)
+    google-protobuf (3.23.4-arm64-darwin)
+    hashdiff (1.0.1)
+    json (2.6.3)
+    language_server-protocol (3.17.0.3)
+    parallel (1.23.0)
+    parser (3.2.2.3)
+      ast (~> 2.4.1)
+      racc
+    public_suffix (5.0.3)
+    racc (1.7.1)
+    rainbow (3.1.1)
+    rake (13.0.6)
+    regexp_parser (2.8.1)
+    rexml (3.2.5)
+    rspec (3.12.0)
+      rspec-core (~> 3.12.0)
+      rspec-expectations (~> 3.12.0)
+      rspec-mocks (~> 3.12.0)
+    rspec-core (3.12.2)
+      rspec-support (~> 3.12.0)
+    rspec-expectations (3.12.3)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.12.0)
+    rspec-mocks (3.12.6)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.12.0)
+    rspec-support (3.12.1)
+    rubocop (1.54.2)
+      json (~> 2.3)
+      language_server-protocol (>= 3.17.0)
+      parallel (~> 1.10)
+      parser (>= 3.2.2.3)
+      rainbow (>= 2.2.2, < 4.0)
+      regexp_parser (>= 1.8, < 3.0)
+      rexml (>= 3.2.5, < 4.0)
+      rubocop-ast (>= 1.28.0, < 2.0)
+      ruby-progressbar (~> 1.7)
+      unicode-display_width (>= 2.4.0, < 3.0)
+    rubocop-ast (1.29.0)
+      parser (>= 3.2.1.0)
+    rubocop-capybara (2.18.0)
+      rubocop (~> 1.41)
+    rubocop-factory_bot (2.23.1)
+      rubocop (~> 1.33)
+    rubocop-rake (0.6.0)
+      rubocop (~> 1.0)
+    rubocop-rspec (2.22.0)
+      rubocop (~> 1.33)
+      rubocop-capybara (~> 2.17)
+      rubocop-factory_bot (~> 2.22)
+    rubocop-shopify (2.14.0)
+      rubocop (~> 1.51)
+    ruby-progressbar (1.13.0)
+    simplecov (0.22.0)
+      docile (~> 1.1)
+      simplecov-html (~> 0.11)
+      simplecov_json_formatter (~> 0.1)
+    simplecov-html (0.12.3)
+    simplecov_json_formatter (0.1.4)
+    unicode-display_width (2.4.2)
+    vcr (6.2.0)
+    webmock (3.18.1)
+      addressable (>= 2.8.0)
+      crack (>= 0.3.2)
+      hashdiff (>= 0.4.0, < 2.0.0)
+    zeitwerk (2.6.8)
+
+PLATFORMS
+  arm64-darwin-22
+
+DEPENDENCIES
+  connect-ruby!
+  rake (~> 13.0)
+  rspec (~> 3.12)
+  rubocop (~> 1.54)
+  rubocop-rake (~> 0.6.0)
+  rubocop-rspec (~> 2.22)
+  rubocop-shopify (~> 2.14)
+  simplecov (~> 0.22.0)
+  vcr (~> 6.2)
+  webmock (~> 3.18)
+
+BUNDLED WITH
+   2.4.13

data/lib/connect/client.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module Connect
+  class Client
+    extend DSL
+
+    class << self
+      def on_rpc_method_added(method)
+        define_method(method.ruby_method) do |input, header: {}, trailer: {}|
+          call(method: method, input: input, header: header, trailer: trailer)
+        end
+      end
+    end
+
+    attr_reader :transport
+
+    def initialize(transport:)
+      @transport = transport
+    end
+
+    def call(method:, input:, header: {}, trailer: {})
+      if method.unary?
+        transport.unary(service: service, method: method, input: input, header: header, trailer: trailer)
+      elsif method.stream?
+        transport.stream(service: service, method: method, input: input, header: header, trailer: trailer)
+      else
+        raise UnknownMethodError, "Unknown method type: #{method.class}"
+      end
+    end
+
+    def service
+      self.class.service
+    end
+  end
+end

data/lib/connect/code.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module Connect
+  class Code
+    class << self
+      def from_http_code(code)
+        case code.to_i
+        when 200 then Ok
+        when 400 then InvalidArgument
+        when 401 then Unauthenticated
+        when 403 then PermissionDenied
+        when 404 then NotFound
+        when 408 then DeadlineExceeded
+        when 409 then Aborted
+        when 412 then FailedPrecondition
+        when 413 then ResourceExhausted
+        when 415 then Internal
+        when 429 then Unavailable
+        when 431 then ResourceExhausted
+        when 502, 503, 504 then Unavailable
+        else
+          Unknown
+        end
+      end
+
+      def from_name(name)
+        CODES_BY_NAME.fetch(name, Unknown)
+      end
+    end
+
+    attr_reader :name, :value
+
+    def initialize(name, value)
+      @name = name
+      @value = value
+    end
+
+    def ==(other)
+      other.is_a?(Code) && name == other.name && value == other.value
+    end
+
+    def inspect
+      "#<#{self.class.name} name=#{name.inspect} value=#{value.inspect}>"
+    end
+  end
+end

data/lib/connect/compression/gzip.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Connect
+  module Compression
+    class Gzip
+      class << self
+        def name
+          "gzip"
+        end
+
+        def compress(source)
+          Zlib.gzip(source)
+        end
+
+        def decompress(source)
+          Zlib.gunzip(source)
+        end
+      end
+    end
+  end
+end

data/lib/connect/dsl.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+module Connect
+  module DSL
+    def service
+      @service
+    end
+
+    def service=(service)
+      @service = service
+    end
+
+    def rpc(name, request, response, ruby_method: nil)
+      method = Method.new(
+        name: name.to_sym,
+        request_type: wrap_message_type(request),
+        response_type: wrap_message_type(response),
+        ruby_method: ruby_method&.to_sym || underscore(name).to_sym,
+      )
+      rpcs[name] = method
+
+      on_rpc_method_added(method)
+    end
+
+    def rpcs
+      @rpcs ||= {}
+    end
+
+    def on_rpc_method_added(method)
+    end
+
+    private
+
+    def wrap_message_type(klass)
+      case klass
+      when Method::Unary
+        klass
+      when Method::Stream
+        klass
+      else
+        unary(klass)
+      end
+    end
+
+    def unary(klass)
+      Method::Unary.new(klass)
+    end
+
+    def stream(klass)
+      Method::Stream.new(klass)
+    end
+
+    def underscore(string)
+      s = string.to_s.dup
+      s.gsub!(/([A-Z]+)([A-Z][a-z])/, '\1_\2')
+      s.gsub!(/([a-z\d])([A-Z])/, '\1_\2')
+      s.tr!("-", "_")
+      s.downcase!
+      s
+    end
+  end
+end

data/lib/connect/envelope.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module Connect
+  class Envelope
+    COMPRESSED_FLAG = 0b00000001
+
+    class << self
+      def pack(source, compression: nil, compress_min_bytes: nil)
+        if compress_min_bytes.nil? || source.bytesize < compress_min_bytes || compression.nil?
+          [0, source.bytesize, source].pack("CNa*")
+        else
+          compressed = compression.compress(source)
+          [COMPRESSED_FLAG, compressed.bytesize, compressed].pack("CNa*")
+        end
+      end
+
+      def unpack(source, compression: nil)
+        flags, size = source.read(5).unpack("CN")
+
+        if flags & COMPRESSED_FLAG == 0
+          [flags, source.read(size)]
+        else
+          [flags, compression.decompress(source.read(size))]
+        end
+      end
+    end
+  end
+end

data/lib/connect/error.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Connect
+  class Error < StandardError
+    attr_reader :code, :message, :details, :metadata
+
+    def initialize(code:, message: nil, details: nil, metadata: nil)
+      super(message)
+
+      @code = code
+      @message = message
+      @details = details
+      @metadata = metadata
+    end
+  end
+end

data/lib/connect/method.rb

@@ -0,0 +1,95 @@
+# frozen_string_literal: true
+
+module Connect
+  class Method
+    class Type
+      attr_reader :klass
+
+      def initialize(klass)
+        @klass = klass
+      end
+
+      def encode(input)
+        klass.encode(input)
+      end
+
+      def decode(input)
+        klass.decode(input)
+      end
+
+      def unary?
+        false
+      end
+
+      def stream?
+        false
+      end
+
+      def ==(other)
+        other.is_a?(Type) && klass == other.klass
+      end
+
+      def inspect
+        "#{self.class.name}<#{klass.inspect}>"
+      end
+    end
+
+    class Unary < Type
+      def unary?
+        true
+      end
+    end
+
+    class Stream < Type
+      def stream?
+        true
+      end
+    end
+
+    attr_reader :name, :request_type, :response_type, :ruby_method
+
+    def initialize(name:, request_type:, response_type:, ruby_method:)
+      @name = name
+      @request_type = request_type
+      @response_type = response_type
+      @ruby_method = ruby_method
+    end
+
+    def unary?
+      request_type.unary? && response_type.unary?
+    end
+
+    def stream?
+      request_type.stream? || response_type.stream?
+    end
+
+    def bidi_stream?
+      request_type.stream? && response_type.stream?
+    end
+
+    def encode_request(input, max_bytes:)
+      output = request_type.encode(input)
+      raise MaxBytesExceededError, "Request exceeded maximum size of #{max_bytes} bytes" if output.bytesize > max_bytes
+
+      output
+    end
+
+    def decode_response(input, max_bytes:)
+      raise MaxBytesExceededError, "Response exceeded maximum size of #{max_bytes} bytes" if input.bytesize > max_bytes
+
+      response_type.decode(input)
+    end
+
+    def ==(other)
+      other.is_a?(Method) &&
+        name == other.name &&
+        request_type == other.request_type &&
+        response_type == other.response_type &&
+        ruby_method == other.ruby_method
+    end
+
+    def inspect
+      "#<#{self.class.name} name=#{name.inspect} request_type=#{request_type.inspect} response_type=#{response_type.inspect} ruby_method=#{ruby_method.inspect}>" # rubocop:disable Layout/LineLength
+    end
+  end
+end

data/lib/connect/request_compression.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Connect
+  class RequestCompression
+    attr_reader :compression, :compress_min_bytes
+
+    def initialize(compression:, compress_min_bytes:)
+      @compression = compression
+      @compress_min_bytes = compress_min_bytes
+    end
+
+    def compress?(source)
+      source.bytesize >= compress_min_bytes
+    end
+  end
+end

data/lib/connect/service.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module Connect
+  class Service
+    extend DSL
+
+    class << self
+      def on_rpc_method_added(method)
+      end
+    end
+  end
+end

data/lib/connect/stream_response.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+module Connect
+  class StreamResponse
+    include Enumerable
+
+    END_OF_STREAM_FLAG = 0b00000010
+
+    attr_reader :header
+
+    def initialize(header:, enumerator:)
+      @header = header
+      @enumerator = enumerator
+      @trailer = nil
+      @error = nil
+      @stream_exhausted = false
+    end
+
+    def each(&block)
+      enumerator.each do |flags, message|
+        if flags & END_OF_STREAM_FLAG == 0
+          yield message
+        else
+          read_end_stream_message(message)
+        end
+      end
+
+      raise InvalidStreamResponseError, "Stream did not end with end stream message" unless stream_exhausted?
+    end
+
+    def trailer
+      raise StreamReadError, "Cannot read trailer before stream is exhausted" unless stream_exhausted?
+
+      @trailer
+    end
+
+    def error
+      raise StreamReadError, "Cannot read error before stream is exhausted" unless stream_exhausted?
+
+      @error
+    end
+
+    def stream_exhausted?
+      @stream_exhausted
+    end
+
+    private
+
+    attr_reader :enumerator
+
+    attr_writer :trailer, :error
+
+    def read_end_stream_message(message)
+      @stream_exhausted = true
+
+      @trailer = message["metadata"]
+      @error = message["error"]
+
+      raise Error.new(
+        code: Code.from_name(error["code"]),
+        message: error["message"],
+        details: error["details"],
+        metadata: error["metadata"],
+      ) if error
+    end
+  end
+end

data/lib/connect/transport.rb

@@ -0,0 +1,259 @@
+# frozen_string_literal: true
+
+module Connect
+  class Transport
+    attr_reader :base_url,
+      :accept_compression,
+      :send_compression,
+      :compress_min_bytes,
+      :read_max_bytes,
+      :write_max_bytes
+
+    def initialize(
+      base_url:,
+      accept_compression: [Compression::Gzip],
+      send_compression: Compression::Gzip,
+      compress_min_bytes: 1024,
+      read_max_bytes: 0xffffffff,
+      write_max_bytes: 0xffffffff
+    )
+      @base_url = base_url
+      @accept_compression = accept_compression
+      @send_compression = send_compression
+      @compress_min_bytes = compress_min_bytes
+      @read_max_bytes = read_max_bytes
+      @write_max_bytes = write_max_bytes
+    end
+
+    def unary(service:, method:, input:, header:, trailer:)
+      uri = build_uri(service: service, method: method)
+
+      response = do_response(
+        uri: uri,
+        request: build_unary_request(uri: uri, method: method, input: input, header: header, trailer: trailer),
+      )
+
+      case response.code
+      when "200"
+        parse_unary_response(response: response, method: method)
+      else
+        raise parse_unary_error(response: response)
+      end
+    end
+
+    def stream(service:, method:, input:, header:, trailer:)
+      raise NotImplementedError, "Bidi streaming is not supported with HTTP/1.1" if method.bidi_stream?
+
+      uri = build_uri(service: service, method: method)
+
+      response = do_response(
+        uri: uri,
+        request: build_stream_request(uri: uri, method: method, input: input, header: header, trailer: trailer),
+      )
+
+      case response.code
+      when "200"
+        parse_stream_response(response: response, method: method)
+      else
+        raise Connect::Error.new(
+          code: Code.for_http_code(response.code),
+          message: "Unexpected HTTP status code: #{response.code}",
+        )
+      end
+    end
+
+    private
+
+    def build_uri(service:, method:)
+      URI("#{base_url}/#{service}/#{method.name}")
+    end
+
+    def do_response(uri:, request:)
+      Net::HTTP.start(uri.hostname, uri.port, use_ssl: uri.scheme == "https") do |http|
+        http.request(request)
+      end
+    end
+
+    def build_unary_request(uri:, method:, input:, header:, trailer:)
+      request = Net::HTTP::Post.new(uri)
+
+      request[CONNECT_HEADER_PROTOCOL_VERSION] = CONNECT_PROTOCOL_VERSION
+      request[CONNECT_HEADER_CONTENT_TYPE] = "application/proto"
+
+      request[CONNECT_UNARY_HEADER_ACCEPT_COMPRESSION] = if accept_compression.any?
+        accept_compression.map(&:name).join(",")
+      else
+        CONNECT_COMPRESSION_IDENTITY
+      end
+
+      if send_compression
+        request_compression = RequestCompression.new(
+          compression: send_compression,
+          compress_min_bytes: compress_min_bytes,
+        )
+      end
+
+      message = method.encode_request(input, max_bytes: write_max_bytes)
+
+      if request_compression&.compress?(message)
+        request[CONNECT_UNARY_HEADER_COMPRESSION] = request_compression.compression.name
+        request.body = request_compression.compression.compress(message)
+      else
+        request.body = message
+      end
+
+      inject_header_and_trailer(request: request, header: header, trailer: trailer)
+    end
+
+    def parse_unary_response(response:, method:)
+      compression = parse_compression_from_header(response[CONNECT_UNARY_HEADER_COMPRESSION])
+
+      message = if compression
+        method.decode_response(compression.decompress(response.body), max_bytes: read_max_bytes)
+      else
+        method.decode_response(response.body, max_bytes: read_max_bytes)
+      end
+
+      header, trailer = parse_header_and_trailer(response: response)
+
+      UnaryResponse.new(header: header, message: message, trailer: trailer)
+    end
+
+    def parse_unary_error(response:)
+      message = JSON.parse(response.body)
+
+      Error.new(
+        code: message.fetch("code", Code.from_http_code(response.code)),
+        message: message["message"],
+        details: message["details"],
+      )
+    rescue JSON::ParserError
+      Error.new(code: Code.from_http_code(response.code))
+    end
+
+    def build_stream_request(uri:, method:, input:, header:, trailer:)
+      request = Net::HTTP::Post.new(uri)
+
+      request[CONNECT_HEADER_PROTOCOL_VERSION] = CONNECT_PROTOCOL_VERSION
+      request[CONNECT_HEADER_CONTENT_TYPE] = "application/connect+proto"
+
+      request[CONNECT_UNARY_HEADER_ACCEPT_COMPRESSION] = CONNECT_COMPRESSION_IDENTITY
+
+      request[CONNECT_STREAM_HEADER_ACCEPT_COMPRESSION] = if accept_compression.any?
+        accept_compression.map(&:name).join(",")
+      else
+        CONNECT_COMPRESSION_IDENTITY
+      end
+
+      if send_compression
+        request_compression = RequestCompression.new(
+          compression: send_compression,
+          compress_min_bytes: compress_min_bytes,
+        )
+        request[CONNECT_STREAM_HEADER_COMPRESSION] = request_compression.compression.name
+      end
+
+      buffer = StringIO.new
+
+      enumerator = build_stream_request_enumerator(
+        method: method,
+        input: input.is_a?(Enumerable) ? input : [input],
+        request_compression: request_compression,
+      )
+
+      enumerator.each do |enveloped|
+        buffer << enveloped
+      end
+
+      buffer.rewind
+
+      request["transfer-encoding"] = "chunked"
+      request.body_stream = buffer
+
+      inject_header_and_trailer(request: request, header: header, trailer: trailer)
+    end
+
+    def parse_stream_response(response:, method:)
+      compression = parse_compression_from_header(response[CONNECT_STREAM_HEADER_COMPRESSION])
+
+      enumerator = build_stream_response_enumerator(
+        method: method,
+        buffer: StringIO.new(response.body),
+        compression: compression,
+      )
+
+      StreamResponse.new(header: response.each_header.to_h, enumerator: enumerator)
+    end
+
+    def build_stream_request_enumerator(method:, input:, request_compression:)
+      Enumerator.new do |yielder|
+        input.each do |message|
+          yielder << Envelope.pack(
+            method.encode_request(message, max_bytes: write_max_bytes),
+            compression: request_compression&.compression,
+            compress_min_bytes: request_compression&.compress_min_bytes,
+          )
+        end
+      end
+    end
+
+    def build_stream_response_enumerator(method:, buffer:, compression:)
+      Enumerator.new do |yielder|
+        until buffer.eof?
+          flags, data = Envelope.unpack(buffer, compression: compression)
+
+          yielder << if flags & 2 == 0
+            [flags, method.decode_response(data, max_bytes: read_max_bytes)]
+          else
+            [flags, parse_end_stream_message(data)]
+          end
+        end
+      end
+    end
+
+    def parse_end_stream_message(data)
+      JSON.parse(data)
+    rescue JSON::ParserError
+      raise InvalidStreamResponseError, "Invalid end stream message: #{data.inspect}"
+    end
+
+    def inject_header_and_trailer(request:, header:, trailer:)
+      header.each do |key, value|
+        request[key] = value
+      end
+
+      trailer.each do |key, value|
+        request["#{CONNECT_UNARY_TRAILER_PREFIX}#{key}"] = value
+      end
+
+      request
+    end
+
+    def parse_header_and_trailer(response:, header: {}, trailer: {})
+      response.each_header do |key, value|
+        if key.start_with?(CONNECT_UNARY_TRAILER_PREFIX)
+          trailer[key[CONNECT_UNARY_TRAILER_PREFIX.length..-1]] = value
+        else
+          header[key] = value
+        end
+      end
+
+      [header, trailer]
+    end
+
+    def parse_compression_from_header(header)
+      if header && header != CONNECT_COMPRESSION_IDENTITY
+        compression = accept_compression.find { |c| c.name == header }
+
+        unless compression
+          accepted = accept_compression.map(&:name)
+
+          raise UnknownCompressionError,
+            "Received unknown compression: #{header}. Supported encodings are: #{accepted.inspect}"
+        end
+
+        compression
+      end
+    end
+  end
+end

data/lib/connect/unary_response.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Connect
+  class UnaryResponse
+    attr_reader :header, :message, :trailer
+
+    def initialize(header:, message:, trailer:)
+      @header = header
+      @message = message
+      @trailer = trailer
+    end
+  end
+end

data/lib/connect/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Connect
+  VERSION = "0.1.0"
+end

data/lib/connect-ruby.rb

@@ -0,0 +1,3 @@
+# frozen_string_literal: true
+
+require "connect"

data/lib/connect.rb

@@ -0,0 +1,93 @@
+# frozen_string_literal: true
+
+require "uri"
+require "json"
+require "stringio"
+require "net/http"
+require "zlib"
+require "google/protobuf"
+require "zeitwerk"
+
+loader = Zeitwerk::Loader.for_gem
+loader.ignore("#{__dir__}/connect-ruby.rb")
+loader.inflector.inflect(
+  "dsl" => "DSL",
+)
+loader.setup
+
+module Connect
+  UnknownMethodError = Class.new(StandardError)
+  MaxBytesExceededError = Class.new(StandardError)
+  InvalidStreamResponseError = Class.new(StandardError)
+  StreamReadError = Class.new(StandardError)
+  UnknownCompressionError = Class.new(StandardError)
+
+  Ok = Code.new("ok", 0)
+  Canceled = Code.new("canceled", 1)
+  Unknown = Code.new("unknown", 2)
+  InvalidArgument = Code.new("invalid_argument", 3)
+  DeadlineExceeded = Code.new("deadline_exceeded", 4)
+  NotFound = Code.new("not_found", 5)
+  AlreadyExists = Code.new("already_exists", 6)
+  PermissionDenied = Code.new("permission_denied", 7)
+  ResourceExhausted = Code.new("resource_exhausted", 8)
+  FailedPrecondition = Code.new("failed_precondition", 9)
+  Aborted = Code.new("aborted", 10)
+  OutOfRange = Code.new("out_of_range", 11)
+  Unimplemented = Code.new("unimplemented", 12)
+  Internal = Code.new("internal", 13)
+  Unavailable = Code.new("unavailable", 14)
+  DataLoss = Code.new("data_loss", 15)
+  Unauthenticated = Code.new("unauthenticated", 16)
+
+  CODES = [
+    Ok,
+    Canceled,
+    Unknown,
+    InvalidArgument,
+    DeadlineExceeded,
+    NotFound,
+    AlreadyExists,
+    PermissionDenied,
+    ResourceExhausted,
+    FailedPrecondition,
+    Aborted,
+    OutOfRange,
+    Unimplemented,
+    Internal,
+    Unavailable,
+    DataLoss,
+    Unauthenticated,
+  ]
+
+  CODES_BY_NAME = {
+    "ok" => Ok,
+    "canceled" => Canceled,
+    "unknown" => Unknown,
+    "invalid_argument" => InvalidArgument,
+    "deadline_exceeded" => DeadlineExceeded,
+    "not_found" => NotFound,
+    "already_exists" => AlreadyExists,
+    "permission_denied" => PermissionDenied,
+    "resource_exhausted" => ResourceExhausted,
+    "failed_precondition" => FailedPrecondition,
+    "aborted" => Aborted,
+    "out_of_range" => OutOfRange,
+    "unimplemented" => Unimplemented,
+    "internal" => Internal,
+    "unavailable" => Unavailable,
+    "data_loss" => DataLoss,
+    "unauthenticated" => Unauthenticated,
+  }.freeze
+
+  CONNECT_HEADER_CONTENT_TYPE = "content-type"
+  CONNECT_UNARY_HEADER_COMPRESSION = "content-encoding"
+  CONNECT_UNARY_HEADER_ACCEPT_COMPRESSION = "accept-encoding"
+  CONNECT_STREAM_HEADER_COMPRESSION = "connect-content-encoding"
+  CONNECT_STREAM_HEADER_ACCEPT_COMPRESSION = "connect-accept-encoding"
+  CONNECT_UNARY_TRAILER_PREFIX = "trailer-"
+  CONNECT_UNARY_HEADER_TIMEOUT = "connect-timeout-ms"
+  CONNECT_HEADER_PROTOCOL_VERSION = "connect-protocol-version"
+  CONNECT_PROTOCOL_VERSION = "1"
+  CONNECT_COMPRESSION_IDENTITY = "identity"
+end

metadata

@@ -0,0 +1,92 @@
+--- !ruby/object:Gem::Specification
+name: connect-ruby
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Brave Hager
+autorequire:
+bindir: exe
+cert_chain: []
+date: 2023-07-16 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: google-protobuf
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.23'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.23'
+- !ruby/object:Gem::Dependency
+  name: zeitwerk
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.6'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.6'
+description:
+email:
+- bravehager@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- Gemfile
+- Gemfile.lock
+- lib/connect-ruby.rb
+- lib/connect.rb
+- lib/connect/client.rb
+- lib/connect/code.rb
+- lib/connect/compression/gzip.rb
+- lib/connect/dsl.rb
+- lib/connect/envelope.rb
+- lib/connect/error.rb
+- lib/connect/method.rb
+- lib/connect/request_compression.rb
+- lib/connect/service.rb
+- lib/connect/stream_response.rb
+- lib/connect/transport.rb
+- lib/connect/unary_response.rb
+- lib/connect/version.rb
+homepage: https://github.com/bravehager/connect-ruby
+licenses: []
+metadata:
+  allowed_push_host: https://rubygems.org
+  rubygems_mfa_required: 'true'
+  homepage_uri: https://github.com/bravehager/connect-ruby
+  source_code_uri: https://github.com/bravehager/connect-ruby
+  changelog_uri: https://github.com/bravehager/connect-ruby/releases
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.0.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.4.13
+signing_key:
+specification_version: 4
+summary: Idiomatic Connect RPCs for Ruby.
+test_files: []