alchemrest 3.1.0

data/lib/alchemrest/hash_path.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+module Alchemrest
+  # A utility for executing transformations against hashes scoped to specific parts of the hash
+  # defined by the `segments` of the path. The `Alchemrest::HashPath` class has one method `#walk`
+  # which will "walk" the path defined by the segments, yielding to a block provided by the calling code
+  # at each node it stops at. In that block, the calling code can transform the hash as it likes
+  #
+  # @example Using `Alchemrest::HashPath` to delete specific nodes from a hash
+  #   input = { user: { accounts: [{account_id: 1, transactions: [{transaction_id: 1, amount: 100}] }] } }
+  #   path = Alchemrest::HashPath.new([:user, :accounts, :transactions, :amount])
+  #   path.walk(input) do |_path, node, remaining_segments|
+  #     if(remaining_segments.count == 1)
+  #       node.delete(remaining_segments.last.key)
+  #     end
+  #   end
+  #   input #=> { user: { accounts: [{account_id: 1, transactions: [{transaction_id: 1}] }] } }
+  class HashPath
+    include Concord::Public.new(:segments)
+
+    # A helper method to quickly build a collection of hash paths from a rails style "StrongParams" hash arg.
+    # @example Create multiple hash paths from a strong params style hash
+    #  Alchemrest::HashPath.build_collection(user: { accounts: { transactions: [:id, :amount] } }) #=>
+    #    [
+    #      Alchemrest::HashPath(segments: [:accounts, :transactions, :id]),
+    #      Alchemrest::HashPath(segments: [:accounts, :transactions, :amount])
+    #    ]
+    def self.build_collection(definition)
+      paths = []
+      visit_leaves(definition) do |value, path|
+        paths << (path + [value])
+      end
+      paths.map { |path| new(path) }
+    end
+
+    # "Walks" the path defined by the segments of the HashPath, including individual items in nested collections.
+    # For each items it walks, it yields to the provided block, passing the current full path to that item, it's value
+    # and the remaining segments of the path it has to walk. If it any point the input does not have a value for one
+    # of the segments, this method will stop traversing that portion of the hash. Note actions taken within the block
+    # are mutative, and will modify the original hash
+    def walk(input, &block)
+      traverse(input, segments, [], &block)
+    end
+
+    class << self
+      private
+
+      def visit_leaves(input, path = [], &block)
+        case input
+          when Hash
+            input.each_with_object(path) do |(key, value), path|
+              visit_leaves(value, path + [key], &block)
+            end
+          when Array
+            input.map { |i| visit_leaves(i, path, &block) }
+          else
+            yield input, path
+        end
+      end
+    end
+
+    private
+
+    def traverse(node, remaining_segments, path, &block) # rubocop:disable Metrics/PerceivedComplexity, Metrics/AbcSize
+      yield path, node, remaining_segments
+
+      return if remaining_segments.empty?
+
+      current_segment = remaining_segments.first
+
+      if node.is_a?(Hash) && node.key?(current_segment)
+        rest_of_segments = remaining_segments[1..]
+        traverse(node[current_segment], rest_of_segments, path + [current_segment], &block)
+      elsif node.is_a?(Array) && node.any?(Hash)
+        node.each_with_index do |item, i|
+          traverse(item, remaining_segments, path + [i], &block) if item.is_a?(Hash)
+        end
+      end
+    end
+  end
+end

data/lib/alchemrest/http_request.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+require 'delegate'
+
+module Alchemrest
+  class HttpRequest < SimpleDelegator
+    extend Memosa
+
+    def initialize(request, client)
+      @client = client
+      super(request)
+    end
+
+    # Have to disable this because mutant wans to
+    # push towards `to_str` which is not available in
+    # 7.1. Once we drop 7.1 support we can remove
+    # mutant:disable
+    def url
+      @client.connection.url_prefix.to_s.chop + path
+    end
+
+    def headers
+      { **default_headers, **super() }
+    end
+
+    def execute!
+      result = Result.for do |try|
+        raw_response = try.unwrap make_request!
+        transform_response(build_response(raw_response))
+      end
+
+      circuit_breaker.monitor!(result:)
+      result
+    end
+
+    private
+
+    def build_response(raw_response)
+      @client.build_response(raw_response)
+    end
+
+    memoize def circuit_breaker
+      @client.configuration.circuit_breaker
+    end
+
+    def make_request!
+      return Result::Error(CircuitOpenError.new) if circuit_breaker.open?
+
+      # We have to set the body in the block form, otherwise it will be ignored for
+      # delete requests. See https://github.com/lostisland/faraday/issues/693#issuecomment-466086832
+      response = @client.connection.public_send(http_method, path, nil, headers) do |req|
+        modify_faraday_request(req)
+      end
+      Result::Ok(response)
+    rescue Faraday::Error => e
+      handle_faraday_error(e)
+    rescue *Alchemrest.rescuable_exceptions => e
+      Result::Error(e)
+    end
+
+    def modify_faraday_request(req)
+      req.body = body unless http_method == 'get'
+    end
+
+    def handle_faraday_error(error)
+      if error.wrapped_exception.instance_of?(Net::OpenTimeout)
+        Result::Error(TimeoutError.new)
+      else
+        raise RequestFailedError
+      end
+    rescue Alchemrest::RequestFailedError => e
+      Result::Error(e)
+    end
+  end
+end

data/lib/alchemrest/kill_switch/adapters.rb

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+require 'active_record'
+
+module Alchemrest
+  class KillSwitch
+    module Adapters
+      class Test
+        class Record
+          include Anima.new(:enabled)
+
+          alias enabled? enabled
+        end
+
+        private_constant :Record
+
+        def initialize
+          @records = {}
+        end
+
+        def ready?
+          true
+        end
+
+        def active?(service_name:)
+          load_record(service_name:).enabled?
+        end
+
+        def activate(service_name:)
+          set(service_name:, enabled: true)
+        end
+
+        def deactivate(service_name:)
+          set(service_name:, enabled: false)
+        end
+
+        private
+
+        def set(service_name:, enabled:)
+          record = load_record(service_name:).with(enabled:)
+          @records[service_name] = record
+        end
+
+        def load_record(service_name:)
+          raise 'service_name cannot be nil' unless service_name
+
+          @records[service_name] ||= Record.new enabled: false
+        end
+      end
+
+      class ActiveRecord
+        class Record < ::ActiveRecord::Base
+          self.table_name = 'alchemrest_kill_switches'
+        end
+
+        private_constant :Record
+
+        def ready?
+          Record.table_exists?
+        end
+
+        def active?(service_name:)
+          load_record(service_name:).enabled?
+        end
+
+        def activate(service_name:)
+          set(service_name:, enabled: true)
+        end
+
+        def deactivate(service_name:)
+          set(service_name:, enabled: false)
+        end
+
+        private
+
+        def set(service_name:, enabled:)
+          load_record(service_name:).update!(enabled:)
+        end
+
+        def load_record(service_name:)
+          raise 'service_name cannot be nil' unless service_name
+
+          Record.find_or_create_by!(service_name:)
+        end
+      end
+    end
+  end
+end

data/lib/alchemrest/kill_switch.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Alchemrest
+  class KillSwitch
+    include Anima.new(:service_name)
+
+    def initialize(service_name:)
+      raise ArgumentError, 'service_name is required' unless service_name
+
+      super
+    end
+
+    def active?
+      adapter.active?(service_name:)
+    end
+
+    def activate!
+      adapter.activate(service_name:)
+    end
+
+    def deactivate!
+      adapter.deactivate(service_name:)
+    end
+
+    private
+
+    def adapter
+      Alchemrest.kill_switch_adapter
+    end
+  end
+end

data/lib/alchemrest/railtie.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require 'rails/railtie'
+
+module Alchemrest
+  class Railtie < ::Rails::Railtie
+    initializer 'alchemrest.logger' do
+      Alchemrest.logger = Rails.logger
+    end
+
+    initializer 'alchemrest.configure_parameter_filter' do |app|
+      config.after_initialize do
+        Alchemrest.filter_parameters += app.config.filter_parameters
+      end
+    end
+
+    initializer 'alchemrest.deprecator' do |app|
+      app.deprecators[:alchemrest] = Alchemrest.deprecator
+    end
+
+    initializer 'alchemrest.deprecator.behavior' do |app|
+      Alchemrest.deprecator.behavior = app.config.active_support.deprecation
+    end
+  end
+end

data/lib/alchemrest/request/endpoint.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Alchemrest
+  class Request
+    class Endpoint < Module
+      include Concord::Public.new(:endpoint_definition)
+
+      def included(_)
+        endpoint = self
+
+        define_method(:endpoint_definition) do
+          endpoint.endpoint_definition
+        end
+
+        include(InstanceMethods)
+      end
+
+      module InstanceMethods
+        def path
+          endpoint_definition.url_for(self)
+        end
+
+        def http_method
+          endpoint_definition.http_method
+        end
+      end
+    end
+  end
+end

data/lib/alchemrest/request/returns.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module Alchemrest
+  class Request
+    class Returns < Module
+      include Concord::Public.new(:domain_type, :path_to_payload, :allow_empty_response)
+
+      def included(request_class)
+        transformer_methods = Module.new
+        returns = self
+
+        transformer_methods.define_method(:response_transformer) do
+          super()
+            .append(Response::Pipeline::ExtractPayload.new(returns.path_to_payload, returns.allow_empty_response))
+            .append(returns.domain_type::TRANSFORM)
+        end
+
+        transformer_methods.define_method(:capture_transformer) do
+          super()
+            .replace_with(Response::Pipeline::Sanitize, returns.sanitize_step)
+            .append(returns.omit_step)
+        end
+
+        request_class.include(transformer_methods)
+      end
+
+      def sanitize_step
+        Response::Pipeline::Sanitize.new(
+          safe: HashPath.build_collection(capture_configuration.safe_paths),
+        )
+      end
+
+      def omit_step
+        Response::Pipeline::Omit.new(
+          HashPath.build_collection(capture_configuration.omitted_paths),
+        )
+      end
+
+      private
+
+      def capture_configuration
+        domain_type.capture_configuration.with_path_to_payload(path_to_payload)
+      end
+    end
+  end
+end

data/lib/alchemrest/request.rb

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+require 'mustermann/expander'
+
+module Alchemrest
+  class Request
+    DEFAULT_HEADERS = IceNine.deep_freeze('User-Agent' => "Alchemrest/#{VERSION}")
+    private_constant(:DEFAULT_HEADERS)
+
+    def self.returns(domain_type, path_to_payload: nil, allow_empty_response: false)
+      include Returns.new(domain_type, path_to_payload, allow_empty_response)
+    end
+
+    def self.endpoint(http_method, template, &block)
+      builder_block = block
+      endpoint_definition = EndpointDefinition.new(template:, http_method: http_method.to_s, builder_block:)
+      include Endpoint.new(endpoint_definition)
+    end
+
+    def self.enable_response_capture
+      define_method(:response_capture_enabled) { true }
+    end
+
+    def self.disable_response_capture
+      define_method(:response_capture_enabled) { false }
+    end
+
+    def path
+      raise NotImplementedError, 'This is an abstract base method. Implement in your subclass.'
+    end
+
+    def http_method
+      raise NotImplementedError, 'This is an abstract base method. Implement in your subclass.'
+    end
+
+    def default_headers
+      DEFAULT_HEADERS
+    end
+
+    def headers
+      {}
+    end
+
+    def body
+      nil
+    end
+
+    def response_transformer
+      Response::Pipeline.new(
+        Response::Pipeline::WasSuccessful.new,
+      )
+    end
+
+    def capture_transformer
+      Response::Pipeline.new(
+        Response::Pipeline::ExtractPayload.new(nil, true),
+        Response::Pipeline::Sanitize.new,
+      )
+    end
+
+    def response_capture_enabled
+      true
+    end
+
+    def transform_response(response)
+      capture!(response:)
+      response_transformer.call(response)
+    end
+
+    def identifier
+      "#{http_method.upcase} #{path}"
+    end
+
+    private
+
+    def capture!(response:)
+      ResponseCapturedHandler.new(request: self, response:).call
+    end
+  end
+end

data/lib/alchemrest/request_definition/builder.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Alchemrest
+  class RequestDefinition
+    class Builder
+      def initialize
+        @defaults = {}
+      end
+
+      attr_accessor :defaults
+    end
+  end
+end

data/lib/alchemrest/request_definition.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Alchemrest
+  # A class that can be used to build an instance of an Alchemrest::Request class. The definition consists of the request class
+  # we want to create, and block that can extract default parameters from an Alchemrest::Root. When we want to build an
+  # instance of the request, call `build_request` and pass in the root as context, with any additional parameters.
+  class RequestDefinition
+    attr_reader :name
+
+    def initialize(name, request_class, &block)
+      @name = name
+      @request_class = request_class
+      @builder_block = block
+    end
+
+    def build_request(context, params = {})
+      builder = Builder.new
+
+      if @builder_block
+        context.instance_exec(builder, &@builder_block)
+      end
+
+      @request_class.new(**builder.defaults.merge(params))
+    end
+  end
+end

data/lib/alchemrest/response/pipeline/extract_payload.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+module Alchemrest
+  class Response
+    class Pipeline
+      # A transform that can extract a nested payload from a response body. Takes in an
+      # array of symbols, strings, or integers that represent the path to the data you care about.
+      # This class assumes the response.body is a hash with string keys, so it calls to_s on all
+      # non integer path elements.
+      class ExtractPayload < Alchemrest::Response::Pipeline::Transform
+        include Concord::Public.new(:path_to_payload, :allow_empty_response)
+
+        # # All symbols will be converted to strings, and integers will be left alone.
+        # @param path_to_payload [Array<Symbol, String, Integer>] The path to the payload you care about
+        # @param _allow_empty_response [bool] Should HTTP 204 OkNoContent empty responses be allowed
+
+        def initialize(_path_to_payload = nil, _allow_empty_response = false) # rubocop:disable Style/OptionalBooleanParameter
+          super
+        end
+
+        def call(response)
+          # If response is empty and the status is 204 (No Content), return nil as the payload
+          if response.no_content_response?
+            return final(nil) if allow_empty_response?
+
+            return failure(ResponsePipelineError.new("Ok but empty response not allowed"))
+          end
+
+          payload = extract_payload(response)
+          if payload.nil?
+            failure(ResponsePipelineError.new("Response body did not contain expected payload at #{path_to_payload}"))
+          else
+            success(payload)
+          end
+        end
+
+        def extract_payload(response)
+          if path_to_payload.nil?
+            response.data
+          else
+            normalized_path = path_to_payload.map do |path_element|
+              if path_element.is_a?(Integer)
+                path_element
+              else
+                path_element.to_s
+              end
+            end
+            response.data.dig(*normalized_path)
+          end
+          # If our path tries to dig into a non hash, we'll get a TypeError. We want to rescue that and ensure
+          # our code continues to safely return a result.
+          rescue TypeError
+            nil
+        end
+
+        private
+
+        def allow_empty_response?
+          allow_empty_response
+        end
+      end
+    end
+  end
+end

data/lib/alchemrest/response/pipeline/final.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Alchemrest
+  class Response
+    class Pipeline
+      class Final
+        include Concord::Public.new(:value)
+      end
+    end
+  end
+end

data/lib/alchemrest/response/pipeline/omit.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module Alchemrest
+  class Response
+    class Pipeline
+      class Omit < Morpher::Transform
+        include Concord::Public.new(:omit)
+        private_constant(*constants(false))
+        PRIMITIVE = Primitive.new(::Hash)
+
+        def initialize(omit = nil)
+          @omit = omit
+          super
+        end
+
+        def call(input)
+          if input.is_a?(::Array)
+            array.call(input)
+          else
+            PRIMITIVE
+              .call(input)
+              .bind { |i| omit_nodes(i) }
+          end
+        end
+
+        def omit_nodes(input)
+          dup = input.dup
+          if omit.present?
+            delete_from(dup)
+          end
+          success(dup)
+        end
+
+        def delete_from(input)
+          omit.each do |path|
+            path.walk(input) do |_path, node, remaining_segments|
+              if remaining_segments.count == 1
+                node.delete(remaining_segments.last)
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/alchemrest/response/pipeline/sanitize.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+module Alchemrest
+  class Response
+    class Pipeline
+      class Sanitize < Morpher::Transform
+        include Anima.new(:safe)
+        PRIMITIVE = Primitive.new(::Hash)
+
+        def initialize(args = { safe: nil })
+          @safe = args[:safe]
+          super
+        end
+
+        def call(input)
+          if input.is_a?(::Array)
+            array.call(input)
+          else
+            PRIMITIVE
+              .call(input)
+              .bind { |i| sanitize(i) }
+          end
+        end
+
+        private
+
+        def sanitize(input)
+          filtered = Alchemrest.parameter_filter.filter(input).with_indifferent_access
+          if safe.present?
+            copy(input, filtered)
+          end
+          success(filtered.deep_symbolize_keys)
+        end
+
+        def copy(original, filtered)
+          safe.each do |safe_path|
+            safe_path.walk(filtered) do |path, filtered_node, remaining_segments|
+              if remaining_segments.count == 1 && filtered_node.is_a?(::Hash)
+                next unless hash_has_key?(original, path, remaining_segments.last)
+
+                original_value = original.with_indifferent_access.dig(*(path + remaining_segments))
+                filtered_node[remaining_segments.last] = original_value
+              end
+            end
+          end
+        end
+
+        def hash_has_key?(hash, path, key)
+          if path.empty?
+            hash.with_indifferent_access.key?(key)
+          else
+            hash.with_indifferent_access.dig(*path)
+              .key?(key)
+          end
+        end
+      end
+    end
+  end
+end