mayak 0.0.2

data/lib/mayak/http/README.md

@@ -0,0 +1,105 @@
+# Http
+
+This module contains abstraction for HTTP interactions. It provides data classes that models HTTP requests and response as well interfaces for http client and codecs.
+
+#### Verb
+
+Enumaration that encodes an HTTP verb.
+
+```ruby
+get_verb     = Mayak::Http::Verb::Get
+post_verb    = Mayak::Http::Verb::Post
+head_verb    = Mayak::Http::Verb::Head
+put_verb     = Mayak::Http::Verb::Put
+patch_verb   = Mayak::Http::Verb::Patch
+delete_verb  = Mayak::Http::Verb::Delete
+connect_verb = Mayak::Http::Verb::Connect
+options_verb = Mayak::Http::Verb::Options
+trace_verb   = Mayak::Http::Verb::Trace
+```
+
+#### Request
+
+`Mayak::Http::Request` is a datastructure that encodes an HTTP request.
+```ruby
+# to build an HTTP request verb and URI should be provided, as well as optional headers hash and body
+request = Mayak::Http::Request.new(
+  verb:     Mayak::Http::Verb::Put,
+  url:      URI.parse("https://www.foobar.com/users/update"),
+  headers:  { "content-type" => "application/json" },
+  body:     """{ id: 100, name: "Daniil" })"""
+)
+
+# to build request helper constructor methods can be used
+get_request = Mayak::Http::Request.get(url: URI.parse("https://www.foobar.com"))
+```
+
+#### Response
+
+`Mayak::Http::Response` is a datastructure that encodes an HTTP request. It contains status, and optional headers and body:
+
+```ruby
+response = Mayak::Http::Response.new(
+  status:  200
+  headers: { "content-type" => "application/json" },
+  body:     """{ id: 100, name: "Daniil" }"""
+)
+```
+
+#### Client
+
+Interface that encodes an HTTP client. The interface is very simple and consists from one method that receives a request and returns a `Try` monad containg response:
+```ruby
+module Mayak
+  module Http
+    module Client
+      extend T::Sig
+      extend T::Generic
+
+      interface!
+
+      sig { abstract.params(request: Http::Request).returns(Mayak::Monads::Try[Mayak::Http::Response]) }
+      def send_request(request)
+      end
+    end
+  end
+end
+```
+
+You can implement this interface using a specific library:
+
+```ruby
+class FaradayClient
+  extend T::Sig
+
+  include Mayak::Http::Client
+
+  include Mayak::Monads::Try::Mixin
+
+  sig { params(config_blk: T.nilable(T.proc.params(connection: Faraday::Connection).void)).void }
+  def initialize(&config_blk)
+    @faraday_instance = T.let(
+      config_blk.nil? ? Faraday.new : Faraday.new(&@config_blk),
+      Faraday
+    )
+  end
+
+  sig { override.params(request: Mayak::Http::Request).returns(Mayak::Monads::Try[Mayak::Http::Response]) }
+  def send_request(request)
+    Try do
+      faraday_response = @faraday_instance.run_request(
+        verb.serialize.downcase.to_sym,
+        request.url,
+        request.body,
+        request.headers
+      )
+
+      Mayak::Http::Response.new(
+        status:  T.must(faraday_response.status.to_i),
+        headers: faraday_response.headers || {},
+        body:    faraday_response.body || ""
+      )
+    end
+  end
+end
+```

data/lib/mayak/http/client.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+# typed: strict
+
+module Mayak
+  module Http
+    module Client
+      extend T::Sig
+      extend T::Generic
+
+      interface!
+
+      sig { abstract.params(request: Http::Request).returns(Mayak::Monads::Try[Mayak::Http::Response]) }
+      def send_request(request)
+      end
+    end
+  end
+end

data/lib/mayak/http/codec.rb

@@ -0,0 +1,23 @@
+# typed: strong
+# frozen_string_literal: true
+
+require_relative 'encoder'
+require_relative 'decoder'
+
+module Mayak
+  module Http
+    module Codec
+      extend T::Sig
+      extend T::Generic
+      extend T::Helpers
+
+      interface!
+
+      include Mayak::Http::Encoder
+      include Mayak::Http::Decoder
+
+      RequestEntity  = type_member
+      ResponseEntity = type_member
+    end
+  end
+end

data/lib/mayak/http/decoder.rb

@@ -0,0 +1,43 @@
+# typed: strong
+# frozen_string_literal: true
+
+module Mayak
+  module Http
+    module Decoder
+      extend T::Sig
+      extend T::Generic
+      extend T::Helpers
+
+      interface!
+
+      ResponseEntity = type_member
+
+      sig {
+        abstract
+          .params(response: Mayak::Http::Response)
+          .returns(Mayak::Monads::Try[ResponseEntity])
+      }
+      def decode(response)
+      end
+
+      class IdentityDecoder
+        extend T::Sig
+        extend T::Generic
+        extend T::Helpers
+
+        include ::Mayak::Http::Decoder
+
+        ResponseEntity = type_member { { fixed: ::Mayak::Http::Response } }
+
+        sig {
+          override
+            .params(response: Mayak::Http::Response)
+            .returns(Mayak::Monads::Try[ResponseEntity])
+        }
+        def decode(response)
+          Mayak::Monads::Try::Success[ResponseEntity].new(response)
+        end
+      end
+    end
+  end
+end

data/lib/mayak/http/encoder.rb

@@ -0,0 +1,55 @@
+# typed: strong
+# frozen_string_literal: true
+
+module Mayak
+  module Http
+    module Encoder
+      extend T::Sig
+      extend T::Generic
+      extend T::Helpers
+
+      interface!
+
+      RequestEntity = type_member
+
+      sig { abstract.params(entity: RequestEntity).returns(Mayak::Http::Request) }
+      def encode(entity)
+      end
+
+      class IdentityEncoder
+        extend T::Sig
+        extend T::Generic
+        extend T::Helpers
+
+        include ::Mayak::Http::Encoder
+
+        RequestEntity = type_member { { fixed: ::Mayak::Http::Request } }
+
+        sig { override.params(entity: RequestEntity).returns(Mayak::Http::Request) }
+        def encode(entity)
+          entity
+        end
+      end
+
+      class FromFunction
+        extend T::Sig
+        extend T::Generic
+        extend T::Helpers
+
+        include ::Mayak::Http::Encoder
+
+        RequestEntity = type_member
+
+        sig { params(function: Mayak::Function[RequestEntity, Mayak::Http::Request]).void }
+        def initialize(function)
+          @function = T.let(function, Mayak::Function[RequestEntity, Mayak::Http::Request])
+        end
+
+        sig { override.params(entity: RequestEntity).returns(Mayak::Http::Request) }
+        def encode(entity)
+          @function.call(entity)
+        end
+      end
+    end
+  end
+end

data/lib/mayak/http/request.rb

@@ -0,0 +1,110 @@
+# frozen_string_literal: true
+# typed: strict
+
+require 'uri'
+require_relative 'verb'
+
+module Mayak
+  module Http
+    class Request < T::Struct
+      extend T::Sig
+
+      const :verb,    Mayak::Http::Verb
+      const :url,     URI
+      const :headers, T::Hash[String, String], default: {}
+      const :body,    T.nilable(String)
+      
+      CONTENT_TYPE_HEADER = T.let("Content-Type", String)
+
+      sig(:final) { params(other: Mayak::Http::Request).returns(T::Boolean) }
+      def ==(other)
+        verb == other.verb && url.to_s == other.url.to_s && headers && other.headers && body == other.body
+      end
+
+      sig(:final) { params(other: Mayak::Http::Request).returns(T::Boolean) }
+      def eql?(other)
+        self == other
+      end
+
+      sig { returns(Integer) }
+      def hash
+        [verb, url.to_s, headers, body].hash
+      end
+
+      sig { returns(T.nilable(String)) }
+      def content_type
+        headers[CONTENT_TYPE_HEADER]
+      end
+
+      sig { params(type: String).returns(Mayak::Http::Request) }
+      def with_content_type(type)
+        Mayak::Http::Request.new(
+          verb:    verb,
+          url:     url,
+          headers: headers.merge(CONTENT_TYPE_HEADER => type),
+          body:    body
+        )
+      end
+
+      sig { params(url: URI, headers: T::Hash[String, String], body: T.nilable(String)).returns(Mayak::Http::Request) }
+      def self.get(url:, headers: {}, body: nil)
+        Mayak::Http::Request.new(
+          verb:    Mayak::Http::Verb::Get,
+          url:     url,
+          headers: headers,
+          body:    body
+        )
+      end
+
+      sig { params(url: URI, headers: T::Hash[String, String], body: T.nilable(String)).returns(Mayak::Http::Request) }
+      def self.head(url:, headers: {}, body: nil)
+        Mayak::Http::Request.new(
+          verb:    Mayak::Http::Verb::Head,
+          url:     url,
+          headers: headers,
+          body:    body
+        )
+      end
+
+      sig { params(url: URI, headers: T::Hash[String, String], body: T.nilable(String)).returns(Mayak::Http::Request) }
+      def self.post(url:, headers: {}, body: nil)
+        Mayak::Http::Request.new(
+          verb:    Mayak::Http::Verb::Post,
+          url:     url,
+          headers: headers,
+          body:    body
+        )
+      end
+
+      sig { params(url: URI, headers: T::Hash[String, String], body: T.nilable(String)).returns(Mayak::Http::Request) }
+      def self.put(url:, headers: {}, body: nil)
+        Mayak::Http::Request.new(
+          verb:    Mayak::Http::Verb::Put,
+          url:     url,
+          headers: headers,
+          body:    body
+        )
+      end
+
+      sig { params(url: URI, headers: T::Hash[String, String], body: T.nilable(String)).returns(Mayak::Http::Request) }
+      def self.patch(url:, headers: {}, body: nil)
+        Mayak::Http::Request.new(
+          verb:    Mayak::Http::Verb::Patch,
+          url:     url,
+          headers: headers,
+          body:    body
+        )
+      end
+
+      sig { params(url: URI, headers: T::Hash[String, String], body: T.nilable(String)).returns(Mayak::Http::Request) }
+      def self.delete(url:, headers: {}, body: nil)
+        Mayak::Http::Request.new(
+          verb:    Mayak::Http::Verb::Delete,
+          url:     url,
+          headers: headers,
+          body:    body
+        )
+      end
+    end
+  end
+end

data/lib/mayak/http/response.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+# typed: strict
+
+require "set"
+
+module Mayak
+  module Http
+    class Response < T::Struct
+      extend T::Sig
+
+      SuccessfulStatuses  = T.let(::Set.new(200..299).freeze, T::Set[Integer])
+      StatusesWithoutBody = T.let(::Set.new([204, 304]).freeze, T::Set[Integer])
+
+      const :status,  Integer
+      const :headers, T::Hash[String, String], default: {}
+      const :body,    String, default: ""
+
+      sig { returns(T::Boolean) }
+      def success?
+        SuccessfulStatuses.include?(status)
+      end
+
+      sig { returns(T::Boolean) }
+      def failure?
+        !success?
+      end
+    end
+  end
+end

data/lib/mayak/http/verb.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+# typed: strict
+
+module Mayak
+  module Http
+    class Verb < T::Enum
+      enums do
+        Get     = new("GET")
+        Post    = new("POST")
+        Head    = new("HEAD")
+        Put     = new("PUT")
+        Patch   = new("PATCH")
+        Delete  = new("DELETE")
+        Connect = new("CONNECT")
+        Options = new("OPTIONS")
+        Trace   = new("TRACE")
+      end
+    end
+  end
+end

data/lib/mayak/json.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+# typed: strict
+
+module Mayak
+  module Json
+    extend T::Sig
+
+    JsonType = T.type_alias {
+      T.any(
+        T::Array[T.untyped],
+        T::Hash[T.untyped, T.untyped],
+        String,
+        Integer,
+        Float
+      )
+    }
+
+    class ParsingError < StandardError
+    end
+
+    sig { params(string: String).returns(Mayak::Monads::Try[JsonType]) }
+    def self.parse(string)
+      Mayak::Monads::Try::Success.new(JSON.parse(string))
+    rescue JSON::ParserError => e
+      Mayak::Monads::Try::Failure.new(ParsingError.new(e.message))
+    end
+
+    sig { params(string: String).returns(JsonType) }
+    def self.parse_unsafe!(string)
+      JSON.parse(string)
+    end
+  end
+end