twirbet 0.1.0

data/examples/ping/sorbet/tapioca/config.yml

@@ -0,0 +1,13 @@
+gem:
+  # Add your `gem` command parameters here:
+  #
+  # exclude:
+  # - gem_name
+  # doc: true
+  # workers: 5
+dsl:
+  # Add your `dsl` command parameters here:
+  #
+  # exclude:
+  # - SomeGeneratorName
+  # workers: 5

data/examples/ping/sorbet/tapioca/require.rb

@@ -0,0 +1,5 @@
+# typed: true
+# frozen_string_literal: true
+
+require "google/protobuf"
+require "twirbet"

data/lib/twirbet/client.rb

@@ -0,0 +1,45 @@
+# typed: true
+# frozen_string_literal: true
+
+require "twirbet/dsl"
+require "twirbet/encoding"
+require "twirbet/transport"
+require "twirbet/transports/net_http_transport"
+
+module Twirbet
+  class Client
+    extend T::Sig
+    include DSL
+
+    sig { returns(String) }
+    attr_reader :base_url
+
+    sig { returns(String) }
+    attr_reader :prefix
+
+    sig { returns(Transport) }
+    attr_reader :transport
+
+    sig { params(base_url: String, prefix: String, transport: Transport).void }
+    def initialize(base_url, prefix: "/twirp", transport: Transports::NetHTTPTransport.new)
+      @base_url = base_url
+      @prefix = prefix
+      @transport = transport
+    end
+
+    sig { params(method_name: String, request: T.untyped, headers: T::Hash[String, String]).returns(T.untyped) }
+    def call(method_name, request, headers = {})
+      method = rpc(method_name)
+      raise ArgumentError, "Unknown method: #{method_name}" unless method
+
+      url = "#{base_url}#{prefix}/#{full_name}/#{method_name}"
+      body = Encoding.encode_request(request, method.request)
+      headers = headers.merge({ "Content-Type" => "application/protobuf" })
+
+      response = transport.call(Transport::Request.new(url, body, headers))
+      raise Twirbet::Error.from_response(response) if response.status != 200
+
+      Encoding.decode(response.body, method.response, "application/protobuf")
+    end
+  end
+end

data/lib/twirbet/dsl.rb

@@ -0,0 +1,84 @@
+# typed: true
+# frozen_string_literal: true
+
+require "twirbet/method"
+
+module Twirbet
+  module DSL
+    extend T::Sig
+    extend T::Helpers
+
+    requires_ancestor { Kernel }
+
+    module ClassMethods
+      extend T::Sig
+      extend T::Helpers
+
+      requires_ancestor { Kernel }
+
+      sig { params(name: T.nilable(String)).void }
+      def package(name)
+        @package = name
+      end
+
+      sig { returns(T.nilable(String)) }
+      def package_name
+        @package
+      end
+
+      sig { params(name: String).void }
+      def service(name)
+        @service = name
+      end
+
+      sig { returns(String) }
+      def service_name
+        raise "Unknown service name. Did you forget to call `service`?" if @service.nil?
+
+        @service
+      end
+
+      sig { returns(String) }
+      def full_name
+        if package_name.nil?
+          service_name
+        else
+          "#{package_name}.#{service_name}"
+        end
+      end
+
+      sig { params(name: String, request: Class, response: Class, ruby_method: Symbol).void }
+      def rpc(name, request, response, ruby_method:)
+        method = Method.new(name, request, response, ruby_method: ruby_method)
+        rpcs[method.name] = method
+      end
+
+      sig { returns(T::Hash[String, Method]) }
+      def rpcs
+        @rpcs ||= {}
+      end
+    end
+
+    mixes_in_class_methods(ClassMethods)
+
+    sig { returns(T.nilable(String)) }
+    def package_name
+      self.class.package_name
+    end
+
+    sig { returns(String) }
+    def service_name
+      self.class.service_name
+    end
+
+    sig { returns(String) }
+    def full_name
+      self.class.full_name
+    end
+
+    sig { params(name: String).returns(T.nilable(Method)) }
+    def rpc(name)
+      self.class.rpcs[name]
+    end
+  end
+end

data/lib/twirbet/encoding.rb

@@ -0,0 +1,52 @@
+# typed: true
+# frozen_string_literal: true
+
+module Twirbet
+  module Encoding
+    class << self
+      extend T::Sig
+
+      sig { params(content_type: T.nilable(String)).returns(T::Boolean) }
+      def supported?(content_type)
+        content_type == "application/protobuf" || content_type == "application/json"
+      end
+
+      sig { params(request: T.untyped, klass: Class).returns(T.untyped) }
+      def encode_request(request, klass)
+        T.unsafe(klass).encode(request)
+      end
+
+      sig { params(request: Rack::Request).returns(T.untyped) }
+      def decode_request(request)
+        method = request.env["twirp.method"]
+        raise "Missing `twirp.method` in request environment." if method.nil?
+
+        decode(request.body.read, method.request, request.content_type)
+      end
+
+      sig { params(object: T.untyped, content_type: String).returns(T.untyped) }
+      def encode(object, content_type)
+        case content_type
+        when "application/protobuf"
+          T.unsafe(object).to_proto
+        when "application/json"
+          T.unsafe(object).to_json
+        else
+          raise "Unsupported content type: #{content_type}"
+        end
+      end
+
+      sig { params(object: T.untyped, klass: Class, content_type: String).returns(T.untyped) }
+      def decode(object, klass, content_type)
+        case content_type
+        when "application/protobuf"
+          T.unsafe(klass).decode(object)
+        when "application/json"
+          T.unsafe(klass).decode_json(object)
+        else
+          raise "Unsupported content type: #{content_type}"
+        end
+      end
+    end
+  end
+end

data/lib/twirbet/errors.rb

@@ -0,0 +1,375 @@
+# typed: true
+# frozen_string_literal: true
+
+require "json"
+require "rack"
+require "twirbet/transport"
+
+module Twirbet
+  class BaseError < StandardError
+    extend T::Sig
+    extend T::Helpers
+
+    abstract!
+
+    sig { returns(T::Hash[String, String]) }
+    attr_reader :metadata
+
+    sig { params(message: String, metadata: T::Hash[String, String]).void }
+    def initialize(message, metadata = {})
+      super(message)
+      @metadata = metadata
+    end
+
+    sig { abstract.returns(String) }
+    def code
+    end
+
+    sig { abstract.returns(Integer) }
+    def status
+    end
+
+    sig(:final) { returns(Rack::Response) }
+    def to_rack_response
+      Rack::Response.new(to_json, status, "Content-Type" => "application/json")
+    end
+
+    sig(:final) { returns(String) }
+    def to_json
+      T.unsafe(to_hash).to_json
+    end
+
+    sig(:final) { returns(T::Hash[String, String]) }
+    def to_hash
+      { "code" => code, "msg" => message, "meta" => metadata }
+    end
+  end
+
+  class CanceledError < BaseError
+    extend T::Sig
+
+    sig { override.returns(String) }
+    def code
+      "canceled"
+    end
+
+    sig { override.returns(Integer) }
+    def status
+      400
+    end
+  end
+
+  class UnknownError < BaseError
+    extend T::Sig
+
+    sig { override.returns(String) }
+    def code
+      "unknown"
+    end
+
+    sig { override.returns(Integer) }
+    def status
+      400
+    end
+  end
+
+  class InvalidArgumentError < BaseError
+    extend T::Sig
+
+    sig { override.returns(String) }
+    def code
+      "invalid_argument"
+    end
+
+    sig { override.returns(Integer) }
+    def status
+      400
+    end
+  end
+
+  class MalformedError < BaseError
+    extend T::Sig
+
+    sig { override.returns(String) }
+    def code
+      "malformed"
+    end
+
+    sig { override.returns(Integer) }
+    def status
+      400
+    end
+  end
+
+  class DeadlineExceededError < BaseError
+    extend T::Sig
+
+    sig { override.returns(String) }
+    def code
+      "deadline_exceeded"
+    end
+
+    sig { override.returns(Integer) }
+    def status
+      400
+    end
+  end
+
+  class NotFoundError < BaseError
+    extend T::Sig
+
+    sig { override.returns(String) }
+    def code
+      "not_found"
+    end
+
+    sig { override.returns(Integer) }
+    def status
+      404
+    end
+  end
+
+  class BadRouteError < BaseError
+    extend T::Sig
+
+    sig { override.returns(String) }
+    def code
+      "bad_route"
+    end
+
+    sig { override.returns(Integer) }
+    def status
+      404
+    end
+  end
+
+  class AlreadyExistsError < BaseError
+    extend T::Sig
+
+    sig { override.returns(String) }
+    def code
+      "already_exists"
+    end
+
+    sig { override.returns(Integer) }
+    def status
+      409
+    end
+  end
+
+  class PermissionDeniedError < BaseError
+    extend T::Sig
+
+    sig { override.returns(String) }
+    def code
+      "permission_denied"
+    end
+
+    sig { override.returns(Integer) }
+    def status
+      403
+    end
+  end
+
+  class UnauthenticatedError < BaseError
+    extend T::Sig
+
+    sig { override.returns(String) }
+    def code
+      "unauthenticated"
+    end
+
+    sig { override.returns(Integer) }
+    def status
+      401
+    end
+  end
+
+  class ResourceExhaustedError < BaseError
+    extend T::Sig
+
+    sig { override.returns(String) }
+    def code
+      "resource_exhausted"
+    end
+
+    sig { override.returns(Integer) }
+    def status
+      429
+    end
+  end
+
+  class FailedPreconditionError < BaseError
+    extend T::Sig
+
+    sig { override.returns(String) }
+    def code
+      "failed_precondition"
+    end
+
+    sig { override.returns(Integer) }
+    def status
+      400
+    end
+  end
+
+  class AbortedError < BaseError
+    extend T::Sig
+
+    sig { override.returns(String) }
+    def code
+      "aborted"
+    end
+
+    sig { override.returns(Integer) }
+    def status
+      409
+    end
+  end
+
+  class OutOfRangeError < BaseError
+    extend T::Sig
+
+    sig { override.returns(String) }
+    def code
+      "out_of_range"
+    end
+
+    sig { override.returns(Integer) }
+    def status
+      400
+    end
+  end
+
+  class UnimplementedError < BaseError
+    extend T::Sig
+
+    sig { override.returns(String) }
+    def code
+      "unimplemented"
+    end
+
+    sig { override.returns(Integer) }
+    def status
+      501
+    end
+  end
+
+  class InternalError < BaseError
+    extend T::Sig
+
+    sig { override.returns(String) }
+    def code
+      "internal"
+    end
+
+    sig { override.returns(Integer) }
+    def status
+      500
+    end
+  end
+
+  class UnavailableError < BaseError
+    extend T::Sig
+
+    sig { override.returns(String) }
+    def code
+      "unavailable"
+    end
+
+    sig { override.returns(Integer) }
+    def status
+      503
+    end
+  end
+
+  class DataLossError < BaseError
+    extend T::Sig
+
+    sig { override.returns(String) }
+    def code
+      "data_loss"
+    end
+
+    sig { override.returns(Integer) }
+    def status
+      500
+    end
+  end
+
+  module Error
+    extend T::Sig
+
+    CODE_MAP = T.let({
+      "canceled" => CanceledError,
+      "unknown" => UnknownError,
+      "invalid_argument" => InvalidArgumentError,
+      "malformed" => MalformedError,
+      "deadline_exceeded" => DeadlineExceededError,
+      "not_found" => NotFoundError,
+      "bad_route" => BadRouteError,
+      "already_exists" => AlreadyExistsError,
+      "permission_denied" => PermissionDeniedError,
+      "unauthenticated" => UnauthenticatedError,
+      "resource_exhausted" => ResourceExhaustedError,
+      "failed_precondition" => FailedPreconditionError,
+      "aborted" => AbortedError,
+      "out_of_range" => OutOfRangeError,
+      "unimplemented" => UnimplementedError,
+      "internal" => InternalError,
+      "unavailable" => UnavailableError,
+      "data_loss" => DataLossError,
+    }.freeze, T::Hash[String, T.class_of(BaseError)])
+
+    class << self
+      extend T::Sig
+
+      sig { params(response: Transport::Response).returns(BaseError) }
+      def from_response(response)
+        from_json(response.body)
+      rescue JSON::ParserError
+        from_intermidate(response.status, "Response is not JSON.", response.body)
+      end
+
+      sig { params(status: Integer, reason: String, body: String).returns(BaseError) }
+      def from_intermidate(status, reason, body)
+        code = case status
+        when 400 then "internal"
+        when 401 then "unauthenticated"
+        when 403 then "permission_denied"
+        when 404 then "bad_route"
+        when 429, 502, 503, 504 then "unavailable"
+        else "unknown"
+        end
+
+        build(code, code)
+      end
+
+      sig { params(exception: Exception).returns(BaseError) }
+      def from_exception(exception)
+        case exception
+        when BaseError
+          exception
+        else
+          InternalError.new(exception.message)
+        end
+      end
+
+      sig { params(json: String).returns(BaseError) }
+      def from_json(json)
+        hash = JSON.parse(json)
+        from_hash(hash)
+      end
+
+      sig { params(hash: T::Hash[String, String]).returns(BaseError) }
+      def from_hash(hash)
+        build(hash.fetch("code", "unknown"), hash.fetch("msg", ""))
+      end
+
+      sig { params(code: String, message: String).returns(BaseError) }
+      def build(code, message)
+        CODE_MAP.fetch(code, UnknownError).new(message)
+      end
+    end
+  end
+end

data/lib/twirbet/method.rb

@@ -0,0 +1,34 @@
+# typed: true
+# frozen_string_literal: true
+
+module Twirbet
+  class Method
+    extend T::Sig
+    include Comparable
+
+    sig { returns(String) }
+    attr_reader :name
+
+    sig { returns(Class) }
+    attr_reader :request
+
+    sig { returns(Class) }
+    attr_reader :response
+
+    sig { returns(Symbol) }
+    attr_reader :ruby_method
+
+    sig { params(name: String, request: Class, response: Class, ruby_method: Symbol).void }
+    def initialize(name, request, response, ruby_method:)
+      @name = name
+      @request = request
+      @response = response
+      @ruby_method = ruby_method
+    end
+
+    sig { params(other: T.untyped).returns(Integer) }
+    def <=>(other)
+      [name, request, response, ruby_method] <=> [other.name, other.request, other.response, other.ruby_method]
+    end
+  end
+end

data/lib/twirbet/service.rb

@@ -0,0 +1,85 @@
+# typed: true
+# frozen_string_literal: true
+
+require "rack"
+require "twirbet/dsl"
+require "twirbet/encoding"
+require "twirbet/errors"
+
+module Twirbet
+  class Service
+    extend T::Sig
+    include DSL
+
+    sig { returns(T.untyped) }
+    attr_reader :handler
+
+    def initialize(handler)
+      @handler = handler
+    end
+
+    sig { params(env: T.untyped).returns(T.untyped) }
+    def call(env)
+      request = Rack::Request.new(env)
+      validate_request(request)
+
+      method = request.env["twirp.method"]
+      response = invoke_method(method, request)
+
+      rack_response = Rack::Response.new(response, 200, "Content-Type" => request.content_type)
+      rack_response.finish
+    rescue => e
+      Error.from_exception(e).to_rack_response.finish
+    end
+
+    private
+
+    sig { params(method: Method, request: Rack::Request).returns(T.untyped) }
+    def invoke_method(method, request)
+      begin
+        decoded_request = Encoding.decode_request(request)
+      rescue => e
+        raise MalformedError, "Error decoding request: #{e.message}"
+      end
+      response = handler.public_send(method.ruby_method, decoded_request)
+      Encoding.encode(response, request.content_type)
+    end
+
+    sig { params(request: Rack::Request).void }
+    def validate_request(request)
+      validate_method(request)
+      validate_content_type(request)
+      validate_path(request)
+    end
+
+    sig { params(request: Rack::Request).void }
+    def validate_method(request)
+      return if request.post?
+
+      raise BadRouteError, "Invalid HTTP method: #{request.request_method}. Only POST is allowed."
+    end
+
+    sig { params(request: Rack::Request).void }
+    def validate_content_type(request)
+      return if Encoding.supported?(request.content_type)
+
+      raise BadRouteError, "Unsupported content type: #{request.content_type}."
+    end
+
+    sig { params(request: Rack::Request).void }
+    def validate_path(request)
+      path_parts = request.path_info.split("/")
+
+      if path_parts.length < 3 || path_parts[-2] != full_name
+        raise BadRouteError, "Invalid path: #{request.path_info}."
+      end
+
+      method_name = path_parts[-1]
+
+      method = rpc(method_name)
+      raise BadRouteError, "Invalid method: #{method_name}." if method.nil?
+
+      request.env["twirp.method"] = method
+    end
+  end
+end