strum-cache 0.1.2 → 0.1.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: efaba98c772965cd918f40d6e2cb276869a045076f6847445188623547bec63d
-  data.tar.gz: 53ece08bc876602d5279f0b794cfb312322dcdedaf0b16e16d89b442c8cf93c1
+  metadata.gz: '02513390f401ce8a38fe1ce2b718def9e485bec07e70b6991bc59e54374a7daa'
+  data.tar.gz: da63fa1d376507d2e556f5be5819d1449c127cb014fb237a5a44db2950aa76c6
 SHA512:
-  metadata.gz: bedc338386c5d7c0af603a8af5b86ae8bba15fc7c3c613127ab9c6e2c218aa85a659a01c8da1e0264f6edb660fd742b81b74e42a8327156017999ba93bcd288d
-  data.tar.gz: ccd5267452450fdcde534e386fc94e768f20a5e430f05c820823979c4b8772fbf574ff9dbbe3cd75d8a1600a85b37cab964c61b5f7289e01cd85b48cba2169ad
+  metadata.gz: 45e3dd0e9921dfb795ced1722b8c9e6426f1ebdb5bed5f1f7e29e2b41b826af4f8c5ccb378ca884d7aba144c5e3f685455b2ac4b4aca2e2a41402e810effa966
+  data.tar.gz: 0ee7672065f0c14ce9cb6dbe42a2c2c9cd3d61f40ba1222c2f8f36888c0e1ce68dfdec9da3a53b841ba6afb37cb3fe13b5deaa22944134e6e0f0354706c5cb8a

data/lib/strum/cache.rb

@@ -81,7 +81,13 @@ module Strum
             end
 
             define_method :find_by_id do |resource_id|
-              Strum::CacheUtils::Find.call(resource_code: resource_code, resource_id: resource_id)
+              Strum::CacheUtils::Find.call(resource_code: resource_code, resource_id: resource_id) do |m|
+                m.success { |result| result }
+                m.failure do |errors|
+                  add_errors(errors)
+                  nil
+                end
+              end
             end
 
             define_method :not_found do
@@ -115,7 +121,13 @@ module Strum
             end
 
             define_method :search_by_params do
-              Strum::CacheUtils::Search.call(resource_code: resource_code, params: input)
+              Strum::CacheUtils::Search.call(resource_code: resource_code, params: input) do |m|
+                m.success { |result| result }
+                m.failure do |errors|
+                  add_errors(errors)
+                  nil
+                end
+              end
             end
 
             define_method :not_found do

data/lib/strum/cache/version.rb

@@ -2,6 +2,6 @@
 
 module Strum
   module Cache
-    VERSION = "0.1.2"
+    VERSION = "0.1.3"
   end
 end

data/lib/strum/cache_utils/build_resource_url.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require "strum/cache_utils/shared/mixins/url"
 require "strum/cache_utils/build_resources_url"
 
 module Strum
@@ -7,34 +8,24 @@ module Strum
     # Resource url builder
     class BuildResourceUrl
       include Strum::Service
-
-      def call
-        output(url: File.join(base_url, resource_id.to_s))
-      rescue KeyError
-        Strum::CacheUtils::BuildResourcesUrl.call(resource_code: resource_code, params: { id: resource_id }) do |m|
-          m.success { |result| output(result) }
-          m.failure { |errors| add_errors(errors) }
-        end
-      end
-
-      def audit
-        required(:resource_code, :resource_id)
-      end
+      include Shared::Mixins::Url
 
       private
 
-        def inflector
-          @inflector ||= Dry::Inflector.new
-        end
+        RESOURCE_SUFIX_URL = "RESOURCE_URL"
+        HOST = "BASE_RESOURCE_URL"
 
-        def underscore_resource_code
-          inflector.underscore(resource_code)
+        def audit
+          required(:resource_code, :resource_id)
+          sliced(:resource_code, :resource_id)
         end
 
-        def base_url
-          ENV.fetch("#{underscore_resource_code.upcase}_RESOURCE_URL") do
-            host = ENV.fetch("BASE_RESOURCE_URL")
-            File.join(host, inflector.pluralize(underscore_resource_code.gsub(/_/, "-")))
+        def call
+          output(url: File.join(base_url, resource_id.to_s))
+        rescue KeyError
+          Strum::CacheUtils::BuildResourcesUrl.call(resource_code: resource_code, params: { id: resource_id }) do |m|
+            m.success { |result| output(result) }
+            m.failure { |errors| add_errors(errors) }
           end
         end
     end

data/lib/strum/cache_utils/build_resources_url.rb

@@ -1,33 +1,31 @@
 # frozen_string_literal: true
 
 require "uri"
+require "strum/cache_utils/shared/mixins/url"
 
 module Strum
   module CacheUtils
     # Build url to resource
     class BuildResourcesUrl
       include Strum::Service
+      include Shared::Mixins::Url
 
-      def call
-        underscore_resource_code = inflector.underscore(resource_code)
-        base_url = ENV.fetch("#{underscore_resource_code.upcase}_RESOURCE_SEARCH_URL") do
-          host = ENV.fetch("BASE_RESOURCE_SEARCH_URL")
-          File.join(host, inflector.pluralize(underscore_resource_code.gsub(/_/, "-")))
-        end
-        output(url: base_url, params: params)
-      rescue KeyError
-        add_error("#{resource_code} SEARCH ENV", :not_found)
-      end
+      private
 
-      def audit
-        required(:resource_code, :params)
-        add_error(:params, :hash_required) unless params.is_a?(Hash)
-      end
+        RESOURCE_SUFIX_URL = "RESOURCE_SEARCH_URL"
+        HOST = "BASE_RESOURCE_SEARCH_URL"
 
-      private
+        def audit
+          required(:resource_code, :params)
+          sliced(:resource_code, :params)
+
+          add_error(:params, :hash_required) unless params.is_a?(Hash)
+        end
 
-        def inflector
-          @inflector ||= Dry::Inflector.new
+        def call
+          output(url: base_url, params: params)
+        rescue KeyError
+          add_error("#{resource_code} SEARCH ENV", :not_found)
         end
     end
   end

data/lib/strum/cache_utils/find.rb

@@ -8,6 +8,11 @@ module Strum
     class Find
       include Strum::Service
 
+      def audit
+        required(:resource_code, :resource_id)
+        sliced(:resource_code, :resource_id)
+      end
+
       def call
         Strum::Pipe.call(Strum::CacheUtils::BuildResourceUrl,
                          Strum::CacheUtils::SendRequest,
@@ -17,10 +22,6 @@ module Strum
           m.failure { |errors| add_errors(errors) }
         end
       end
-
-      def audit
-        required(:resource_code, :resource_id)
-      end
     end
   end
 end

data/lib/strum/cache_utils/redis.rb

@@ -10,20 +10,20 @@ module Strum
     class Redis
       include Strum::Service
 
-      def call
-        if (entity = redis_connection.hgetall(resource_id)).key?("id")
-          redis_connection.expire(resource_id, redis_resource_expire)
-          output(entity)
-        else
-          add_error(:entity, :not_found)
-        end
-      end
+      private
 
-      def audit
-        required(:resource_code, :resource_id)
-      end
+        def audit
+          required(:resource_code, :resource_id)
+        end
 
-      private
+        def call
+          if (entity = redis_connection.hgetall(resource_id)).key?("id")
+            redis_connection.expire(resource_id, redis_resource_expire)
+            output(entity)
+          else
+            add_error(:entity, :not_found)
+          end
+        end
 
         def redis_connection
           Strum::CacheUtils::RedisStorage.const_get(resource_code.to_s.capitalize, false).instance.redis

data/lib/strum/cache_utils/search.rb

@@ -1,6 +1,5 @@
 # frozen_string_literal: true
 
-require "strum/pipe"
 require "strum/cache_utils/build_resources_url"
 require "strum/cache_utils/send_request"
 
@@ -10,6 +9,11 @@ module Strum
     class Search
       include Strum::Service
 
+      def audit
+        required(:resource_code, :params)
+        sliced(:resource_code, :params)
+      end
+
       def call
         Strum::Pipe.call(Strum::CacheUtils::BuildResourcesUrl,
                          Strum::CacheUtils::SendRequest,
@@ -19,10 +23,6 @@ module Strum
           m.failure { |errors| add_errors(errors) }
         end
       end
-
-      def audit
-        required(:resource_code, :params)
-      end
     end
   end
 end

data/lib/strum/cache_utils/send_request.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 require "faraday"
-require "json"
+require "faraday_middleware"
 
 module Strum
   module CacheUtils
@@ -9,36 +9,96 @@ module Strum
     class SendRequest
       include Strum::Service
 
-      def call
-        (resp = send_request).success? && output(JSON.parse(resp.body))
-      rescue Faraday::Error => e
-        add_error(:connection, e)
-      rescue JSON::JSONError => e
-        add_error(:payload, e)
-      end
-
-      def audit
-        required :url
-      end
-
       private
 
-        def cache_headers
-          Strum::Cache.config.cache_headers.is_a?(Hash) ? Strum::Cache.config.cache_headers : {}
+        TIMEOUT = ENV.fetch("STRUM_CACHE_TIMEOUT", 50).to_i.freeze
+        OPEN_TIMEOUT = ENV.fetch("STRUM_CACHE_OPEN_TIMEOUT", 5).to_i.freeze
+
+        def audit
+          required(:url)
+          sliced(:url, :params)
         end
 
-        def conn
-          Faraday.new(url: url)
+        def call
+          output(send_request.body)
+        rescue Faraday::ConnectionFailed => e
+          connection_error_handler(e)
+        rescue Faraday::TimeoutError => e
+          timeout_error_handler(e)
+        rescue Faraday::ParsingError => e
+          parsing_error_handler(e)
+        rescue Faraday::Error => e
+          error_handler(e)
         end
 
         def send_request
-          conn.get do |req|
-            req.params = params if input[:params]
-            req.headers["Content-Type"] = "application/json"
+          create_faraday_inst.get do |req|
             req.headers["Accept"] = "application/json"
+            req.headers["Content-Type"] = "application/json"
+            req.params = params if input[:params]
             cache_headers.each { |k, v| req.headers[k] = v }
           end
         end
+
+        def create_faraday_inst
+          Faraday.new(url: url) do |f|
+            f.response :json
+            f.options.timeout = TIMEOUT
+            f.options.open_timeout = OPEN_TIMEOUT
+            f.use Faraday::Response::RaiseError
+          end
+        end
+
+        def cache_headers
+          Strum::Cache.config.cache_headers.is_a?(Hash) ? Strum::Cache.config.cache_headers : {}
+        end
+
+        def connection_error_handler(error)
+          add_error(:send_request, :connection_error)
+          add_error(:connection_error, [{ info: { error_message: error.message, url: url, method: :get } }])
+        end
+
+        def timeout_error_handler(error)
+          add_error(:send_request, :timeout_error)
+          add_error(:timeout_error, [{ info: { error_message: error.message, url: url, method: :get } }])
+        end
+
+        def parsing_error_handler(error) # rubocop: disable Metrics/AbcSize, Style/CommentedKeyword
+          info = {
+            error_message: error.message,
+            request_headers: error.response.env.request_headers,
+            response_status: error.response.env.status,
+            response_headers: error.response.env.response_headers,
+            response_body: error.response.env.response_body
+          }
+          add_error(:payload, error)
+          add_error(:send_request, :json_parse_error)
+          add_error(:json_parse_error, [build_format_info(info)])
+        end
+
+        def error_handler(error)
+          info = {
+            error_message: error.message,
+            request_headers: error.response[:request][:headers],
+            response_status: error.response[:status],
+            response_headers: error.response[:headers],
+            response_body: error.response[:body]
+          }
+
+          add_error(:connection, error)
+          add_error(:send_request, :http_error)
+          add_error(:http_error, [build_format_info(info)])
+        end
+
+        def build_format_info(info)
+          {
+            info: {
+              error_message: info[:error_message], method: :get, url: url,
+              request: { headers: info[:request_headers] },
+              response: { status: info[:response_status], headers: info[:response_headers], body: info[:response_body] }
+            }
+          }
+        end
     end
   end
 end

data/lib/strum/cache_utils/shared/mixins/url.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Strum
+  module CacheUtils
+    module Shared
+      module Mixins
+        # General methods for url builders
+        module Url
+          def base_url
+            ENV.fetch("#{underscore_resource_code.upcase}_#{self.class::RESOURCE_SUFIX_URL}") do
+              host = ENV.fetch(self.class::HOST)
+              File.join(host, inflector.pluralize(underscore_resource_code.gsub(/_/, "-")))
+            end
+          end
+
+          def underscore_resource_code
+            @underscore_resource_code ||= inflector.underscore(resource_code)
+          end
+
+          def inflector
+            @inflector ||= Dry::Inflector.new
+          end
+        end
+      end
+    end
+  end
+end

data/strum-cache.gemspec

@@ -33,7 +33,8 @@ Gem::Specification.new do |spec|
 
   spec.add_runtime_dependency "dry-configurable", "~> 0.12.1"
   spec.add_runtime_dependency "dry-inflector", "~> 0.2"
-  spec.add_runtime_dependency "faraday", "~> 1.1"
+  spec.add_runtime_dependency "faraday", "~> 1.4"
+  spec.add_runtime_dependency "faraday_middleware", "~> 1.0"
   spec.add_runtime_dependency "json", "~> 2.3"
   spec.add_runtime_dependency "redis", "~> 4.2"
   spec.add_runtime_dependency "strum-json", "~> 0.0.3"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: strum-cache
 version: !ruby/object:Gem::Version
-  version: 0.1.2
+  version: 0.1.3
 platform: ruby
 authors:
 - Serhiy Nazarov
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2021-08-04 00:00:00.000000000 Z
+date: 2021-08-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: dry-configurable
@@ -44,14 +44,28 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.1'
+        version: '1.4'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.1'
+        version: '1.4'
+- !ruby/object:Gem::Dependency
+  name: faraday_middleware
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
 - !ruby/object:Gem::Dependency
   name: json
   requirement: !ruby/object:Gem::Requirement
@@ -144,6 +158,7 @@ files:
 - lib/strum/cache_utils/redis_storage.rb
 - lib/strum/cache_utils/search.rb
 - lib/strum/cache_utils/send_request.rb
+- lib/strum/cache_utils/shared/mixins/url.rb
 - strum-cache.gemspec
 homepage: https://gitlab.com/strum-rb/strum-cache
 licenses: []