alchemrest 3.1.0

data/lib/alchemrest/url_builder/options.rb

@@ -0,0 +1,33 @@
+# typed: true
+# frozen_string_literal: true
+
+module Alchemrest
+  class UrlBuilder
+    class Options
+      attr_accessor :values, :query
+
+      attr_reader :query_param_encoder
+
+      InvalidEncoderError = Class.new(StandardError)
+
+      def encode_query_with=(name)
+        @query_param_encoder = Encoders.find(name)
+      rescue NoMatchingPatternError
+        raise InvalidEncoderError, ":#{name} is not a known query string encoder type. Known types are :rack and :form"
+      end
+
+      def encode_query_with(&)
+        @query_param_encoder = Encoders::Custom.new(&)
+      end
+
+      def create_builder(template:)
+        UrlBuilder.new(
+          template:,
+          query: query,
+          values: values,
+          query_param_encoder: query_param_encoder,
+        )
+      end
+    end
+  end
+end

data/lib/alchemrest/url_builder.rb

@@ -0,0 +1,31 @@
+# typed: true
+# frozen_string_literal: true
+
+module Alchemrest
+  class UrlBuilder
+    include Anima.new(:template, :query_param_encoder, :values, :query)
+
+    def initialize(args)
+      super({ values: nil, query: nil, query_param_encoder: Encoders.find(:form) }.merge(**args.compact))
+    end
+
+    def url
+      base = values ? Mustermann::Expander.new(template).expand(values) : template
+
+      if query_string
+        "#{base}?#{query_string}"
+      else
+        base
+      end
+    end
+
+    private
+
+    def query_string
+      return nil unless query
+      return nil if query.compact.empty?
+
+      query_param_encoder.call(query.compact)
+    end
+  end
+end

data/lib/alchemrest/version.rb

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

data/lib/alchemrest/webmock_helpers.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Alchemrest
+  module WebmockHelpers
+    module_function def stub_alchemrest_request(alchemrest_request, with_request_body: false, with_headers: false)
+      stub_url = if defined?(alchemrest_request.url)
+                   alchemrest_request.url
+                 else
+                   Addressable::Template.new("http://{host}#{alchemrest_request.path}")
+                 end
+
+      http_method = alchemrest_request.http_method.to_sym
+
+      stub = if with_request_body
+               stub_request(http_method, stub_url).with(body: alchemrest_request.body)
+             else
+               stub_request(http_method, stub_url)
+             end
+
+      if with_headers
+        stub.with(headers: alchemrest_request.headers)
+      else
+        stub
+      end
+    end
+  end
+end

data/lib/alchemrest.rb

@@ -0,0 +1,159 @@
+# frozen_string_literal: true
+
+require "morpher"
+require "money"
+require 'faraday'
+require 'multi_json'
+require "active_support"
+require "active_support/core_ext/hash"
+require "active_support/core_ext/object"
+require "active_support/parameter_filter"
+require "active_support/hash_with_indifferent_access"
+require "circuitbox"
+require 'sorbet-runtime'
+require "rack/utils"
+require_relative "alchemrest/version"
+require_relative "alchemrest/hash_path"
+require_relative "alchemrest/transforms"
+require_relative "alchemrest/transforms/constrainable"
+require_relative "alchemrest/transforms/from_type"
+require_relative "alchemrest/transforms/to_type"
+require_relative "alchemrest/transforms/to_type/transforms_selector"
+require_relative "alchemrest/transforms/constraint"
+require_relative "alchemrest/transforms/constraint_builder"
+require_relative "alchemrest/transforms/constraint_builder/for_string"
+require_relative "alchemrest/transforms/constraint_builder/for_number"
+require_relative "alchemrest/transforms/constraint/block"
+require_relative "alchemrest/transforms/with_constraint"
+require_relative "alchemrest/data/field"
+require_relative "alchemrest/data/graph"
+require_relative "alchemrest/data/capture_configuration"
+require_relative "alchemrest/data/record"
+require_relative "alchemrest/data/schema"
+require_relative "alchemrest/data"
+require_relative "alchemrest/transforms/base_to_type_transform_registry"
+require_relative "alchemrest/transforms/from_type/empty_to_type_transform_registry"
+
+Dir.glob(File.join(__dir__, 'alchemrest', 'transforms', '*.rb')).each do |file|
+  require_relative file
+end
+
+require_relative "alchemrest/transforms/constraint/matches_regex"
+Dir.glob(File.join(__dir__, 'alchemrest', 'transforms', 'constraint', '*.rb')).each do |file|
+  require_relative file
+end
+
+require_relative "alchemrest/transforms/to_type/from_string_to_time_selector"
+require_relative "alchemrest/transforms/from_string/to_type_transform_registry"
+require_relative "alchemrest/transforms/from_number/to_type_transform_registry"
+require_relative "alchemrest/result"
+require_relative 'alchemrest/result/halt'
+require_relative 'alchemrest/result/try_helpers'
+require_relative "alchemrest/error"
+require_relative "alchemrest/response"
+require_relative "alchemrest/response/pipeline"
+require_relative "alchemrest/response/pipeline/transform"
+require_relative "alchemrest/response/pipeline/was_successful"
+require_relative "alchemrest/response/pipeline/final"
+require_relative "alchemrest/response/pipeline/extract_payload"
+require_relative "alchemrest/response/pipeline/sanitize"
+require_relative "alchemrest/response/pipeline/omit"
+require_relative "alchemrest/response_captured_handler"
+require_relative "alchemrest/client/configuration/connection"
+require_relative "alchemrest/client/configuration"
+require_relative "alchemrest/client"
+require_relative "alchemrest/url_builder"
+require_relative "alchemrest/url_builder/encoders"
+require_relative "alchemrest/url_builder/options"
+require_relative "alchemrest/endpoint_definition"
+require_relative "alchemrest/request/endpoint"
+require_relative "alchemrest/request/returns"
+require_relative "alchemrest/request"
+require_relative "alchemrest/request_definition"
+require_relative "alchemrest/request_definition/builder"
+require_relative "alchemrest/root"
+require_relative "alchemrest/kill_switch"
+require_relative "alchemrest/kill_switch/adapters"
+require_relative "alchemrest/circuit_breaker"
+require_relative "alchemrest/http_request"
+require_relative "alchemrest/faraday_middleware/json_parser"
+require_relative "alchemrest/faraday_middleware/underscore_response"
+require_relative "alchemrest/faraday_middleware/external_api_instrumentation"
+require_relative "alchemrest/faraday_middleware/kill_switch"
+require_relative "alchemrest/webmock_helpers"
+require_relative "alchemrest/factory_bot"
+require_relative "alchemrest/railtie"
+
+module Alchemrest
+  DEFAULT_RESCUABLE_EXCEPTIONS = [Alchemrest::Error].freeze
+
+  DEFAULT_FILTER_PARAMETERS = %i(ssn password token).freeze
+
+  @filter_parameters = DEFAULT_FILTER_PARAMETERS
+
+  def self.logger
+    @logger ||= Logger.new($stdout)
+  end
+
+  def self.logger=(logger)
+    @logger = logger
+  end
+
+  # mutant:disable
+  def self.deprecator
+    @deprecator ||= ActiveSupport::Deprecation.new("3.0", "Alchemrest")
+  end
+
+  def self.filter_parameters
+    @filter_parameters
+  end
+
+  def self.filter_parameters=(params)
+    @filter_parameters = params.uniq
+  end
+
+  def self.parameter_filter
+    ActiveSupport::ParameterFilter.new(@filter_parameters)
+  end
+
+  def self.on_result_rescued(&block)
+    @on_result_rescued = block if block
+  end
+
+  def self.on_response_captured(&block)
+    @on_response_captured = block if block
+    @on_response_captured
+  end
+
+  def self.restore_default_result_rescue_behavior
+    @on_result_rescued = nil
+  end
+
+  def self.restore_default_response_capture_behavior
+    @on_response_captured = nil
+  end
+
+  def self.handle_rescued_result(error)
+    if @on_result_rescued
+      @on_result_rescued.call(error)
+    else
+      logger.warn(error.to_s)
+    end
+  end
+
+  def self.rescuable_exceptions
+    @rescuable_exceptions || DEFAULT_RESCUABLE_EXCEPTIONS
+  end
+
+  def self.rescuable_exceptions=(exceptions)
+    @rescuable_exceptions = exceptions
+  end
+
+  def self.kill_switch_adapter
+    @kill_switch_adapter ||= KillSwitch::Adapters::ActiveRecord.new
+  end
+
+  def self.kill_switch_adapter=(adapter)
+    @kill_switch_adapter = adapter
+  end
+end

data/lib/generators/alchemrest/kill_switch_migration_generator.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require 'rails/generators/migration'
+require 'rails/generators/active_record'
+
+module Alchemrest
+  class KillSwitchMigrationGenerator < Rails::Generators::Base
+    include Rails::Generators::Migration
+
+    source_paths << File.join(File.dirname(__FILE__), 'templates')
+
+    def self.next_migration_number(dirname)
+      ActiveRecord::Generators::Base.next_migration_number dirname
+    end
+
+    def create_migration_file
+      migration_template 'kill_switch_migration.rb.erb', "db/migrate/create_alchemrest_kill_switches.rb",
+                         migration_version:
+    end
+
+    private
+
+    def migration_version
+      "[#{ActiveRecord::VERSION::MAJOR}.#{ActiveRecord::VERSION::MINOR}]" if ActiveRecord::VERSION::MAJOR >= 5
+    end
+  end
+end

data/lib/generators/alchemrest/templates/kill_switch_migration.rb.erb

@@ -0,0 +1,17 @@
+class CreateAlchemrestKillSwitches < ActiveRecord::Migration<%= migration_version %>
+  disable_ddl_transaction!
+
+  def self.up
+    create_table :alchemrest_kill_switches, id: :uuid do |t|
+      t.string  :service_name, null: false
+      t.boolean :enabled, null: false, default: false
+      t.timestamps
+    end
+
+    add_index :alchemrest_kill_switches, [:service_name], name: "index_alchemrest_kill_switches_on_service_name", unique: true, algorithm: :concurrently
+  end
+
+  def self.down
+    drop_table :alchemrest_kill_switches
+  end
+end

data/lib/rubocop/cop/alchemrest/define_request_using_with_params.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Alchemrest
+      class DefineRequestUsingWithParams < RuboCop::Cop::Base
+        extend RuboCop::Cop::AutoCorrector
+
+        MSG = <<~MSG
+          Using `with_params` to set defaults for a request is deprecated.
+          Instead make your block that takes a `request` argument and call `request.defaults = { <some values> }`
+
+            BAD:
+            ```
+            define_request :get_users, GetUsers, with_params: -> { { id: user_id } }
+            ```
+
+            GOOD:
+            ```
+            define_request :get_users, GetUsers do |request|
+              request.defaults = { id: user_id }
+            end
+            ```
+        MSG
+
+        def_node_matcher :on_define_request_with_params_proc_call?, <<~PATTERN
+          (send nil? :define_request $(sym _) $(const ...) $(hash (pair (sym :with_params) $(block ...))))
+        PATTERN
+
+        def on_send(node)
+          on_define_request_with_params_proc_call?(node) do |method_name, klass, with_params_arg, block_node|
+            add_offense(with_params_arg) do |corrector|
+              correction = build_autocorrection(method_name, klass, block_node)
+              corrector.replace(node, correction) if correction
+            end
+          end
+        end
+
+        def build_autocorrection(method_name, klass, block)
+          block_body = block.body
+
+          params_value = block_body.source
+
+          <<~CODE.chomp
+            define_request #{method_name.source}, #{klass.source} do |request|
+              request.defaults = #{params_value}
+            end
+          CODE
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/alchemrest/endpoint_definition_using_generic_params.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Alchemrest
+      class EndpointDefinitionUsingGenericParams < RuboCop::Cop::Base
+        extend RuboCop::Cop::AutoCorrector
+
+        MSG = <<~MSG
+          You are using a generic params hash to build a url, rather than explicitly defining which values in the
+          hash should be inserted into the path of the url, vs which are query string params. This is deprecated,
+          and you should update your code to use `values=` and `query=` instead.
+
+          BAD:
+          endpoint :get, '/api/v1/users/:id' do |url|
+            url.params = { id: @id, includeDetails: true }
+          end
+
+          GOOD:
+          endpoint :get, '/api/v1/users/:id' do |url|
+            url.values = { id: @id }
+            url.query = { includeDetails: true }
+          end
+        MSG
+
+        def_node_matcher :on_endpoint_call?, <<~PATTERN
+          (block (send _ :endpoint ...) (args (arg _)) $_)
+        PATTERN
+
+        def_node_matcher :generic_params_assignment?, <<~PATTERN
+          (send (lvar $_) :params= _)
+        PATTERN
+
+        def on_block(node)
+          on_endpoint_call?(node) do |block_node|
+            if generic_params_assignment?(block_node)
+              add_offense(block_node) do |corrector|
+                correction = build_autocorrection(block_node)
+                corrector.replace(block_node, correction) if correction
+              end
+            end
+          end
+        end
+
+        def build_autocorrection(block)
+          params_value = block.arguments.first.source
+
+          <<~CODE.chomp
+            url.values = #{params_value}
+          CODE
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/alchemrest/request_hash_returning_block.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Alchemrest
+      class RequestHashReturningBlock < RuboCop::Cop::Base
+        extend RuboCop::Cop::AutoCorrector
+
+        MSG = <<~MSG
+          Returning a hash to set url params is deprecated. Instead make your block take a `url` argument and call `url.params = {...}`
+
+            BAD:
+            ```
+            endpoint :get, '/api/users/:id', -> { { id: user_id } }
+            ```
+
+            GOOD:
+            ```
+            endpoint :get, '/api/users/:id' do |url|
+              url.params = { id: user_id }
+            end
+            ```
+        MSG
+
+        def_node_matcher :on_endpoint_params_proc_call?, <<~PATTERN
+          (send nil? :endpoint $(sym _) $({str | dstr} ...) $(block ...))
+        PATTERN
+
+        def on_send(node)
+          on_endpoint_params_proc_call?(node) do |http_method, url, block_node|
+            add_offense(block_node) do |corrector|
+              correction = build_autocorrection(http_method, url, block_node)
+              corrector.replace(node, correction) if correction
+            end
+          end
+        end
+
+        def build_autocorrection(http_method, url, block)
+          block_body = block.body
+
+          params_value = block_body.source
+
+          url_string = url.source
+
+          <<~CODE.chomp
+            endpoint :#{http_method.value}, #{url_string} do |url|
+              url.params = #{params_value}
+            end
+          CODE
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/alchemrest/time_transform_with_no_zone.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Alchemrest
+      class TimeTransformWithNoZone < RuboCop::Cop::Base
+        extend RuboCop::Cop::AutoCorrector
+
+        MSG = <<~MSG
+          Calling `s.from.string.to(Time)` without specifying the timezone is no longer supported
+
+          BAD:
+          ```
+          s.from.string.to(Time)
+          ```
+
+          GOOD:
+          ```
+          s.from.string.to(Time).using(:utc)
+          s.from.string.to(Time).using(:local)
+          s.from.string.to(Time).using(ActiveSupport::TimeZone['Mountain Time (US & Canada)'])
+          ```
+        MSG
+
+        def_node_matcher :on_time_transform?, <<~PATTERN
+          (send (send (send ... :from) :string) :to (const nil? :Time))
+        PATTERN
+
+        def_node_matcher :on_good_time_transform?, <<~PATTERN
+          (send (send (send (send ... :from) :string) :to (const nil? :Time)) :using ...)
+        PATTERN
+
+        def on_hash(node)
+          node.pairs.each do |pair|
+            transform_node = pair.value
+
+            next if on_good_time_transform?(transform_node)
+
+            on_time_transform?(transform_node) do
+              add_offense(transform_node) do |corrector|
+                correction = build_autocorrection(transform_node)
+                corrector.replace(transform_node, correction) if correction
+              end
+            end
+          end
+        end
+
+        def build_autocorrection(node)
+          <<~CODE.chomp
+            #{node.source}.using(:utc)
+          CODE
+        end
+      end
+    end
+  end
+end

data/lib/tapioca/dsl/compilers/alchemrest_data.rb

@@ -0,0 +1,84 @@
+# typed: true
+# frozen_string_literal: true
+
+require 'active_support/core_ext/enumerable'
+require 'alchemrest'
+
+module Tapioca
+  module Dsl
+    module Compilers
+      # This compiler generates RBI files for classes that inherit from `Alchemrest::Data`.
+      #
+      # For example, given the following class:
+      #
+      #   class Profile < Alchemrest::Data
+      #     schema do |s|
+      #       {
+      #         required: {
+      #           name: s.string,
+      #         },
+      #       }
+      #     end
+      #   end
+      #
+      # This compiler will generate an RBI file `profile.rbi` with the following content:
+      #
+      #   sig { returns(::String) }
+      #   def name; end
+      #
+      class AlchemrestData < Tapioca::Dsl::Compiler
+        extend T::Sig
+
+        Type = T.type_alias { T.any(Class, T::Types::Base) }
+
+        ConstantType = type_member { { upper: T.class_of(Alchemrest::Data) } }
+
+        sig { override.returns(T::Enumerable[Module]) }
+        def self.gather_constants
+          descendants_of(Alchemrest::Data)
+        end
+
+        sig { override.void }
+        def decorate
+          root.create_path(constant) do |rbi|
+            constant.graph.fields.each do |name, field|
+              type = T::Utils.coerce(extract_type(field.output_type))
+              rbi.create_method(name.to_s, return_type: type.to_s)
+            end
+          end
+        end
+
+        sig { params(output_type: T.nilable(Alchemrest::Transforms::OutputType)).returns(Type) }
+        def extract_type(output_type)
+          return T.untyped if output_type.nil?
+
+          output_type.sorbet_type
+        end
+
+        sig { params(types: T::Array[Class]).returns(Type) }
+        def extract_output_type(types)
+          types.many? ? T.any(*T.unsafe(types)) : types.sole
+        end
+
+        sig { params(field: Alchemrest::Data::Field).returns(T::Boolean) }
+        def nilable?(field)
+          !field.required || field.transform.is_a?(Morpher::Transform::Maybe)
+        end
+
+        sig { params(transform: Morpher::Transform).returns(T::Boolean) }
+        def array?(transform)
+          case transform
+          when Alchemrest::Transforms::Typed
+            transform.collection
+          when Morpher::Transform::Array
+            true
+          when Morpher::Transform::Maybe
+            array?(transform.send(:transform))
+          else
+            false
+          end
+        end
+      end
+    end
+  end
+end

data/lib/tapioca/dsl/compilers/alchemrest_root.rb

@@ -0,0 +1,68 @@
+# typed: true
+# frozen_string_literal: true
+
+require 'active_support/core_ext/enumerable'
+require 'alchemrest'
+
+module Tapioca
+  module Dsl
+    module Compilers
+      # This compiler generates RBI files for classes that inherit from `Alchemrest::Root`.
+      #
+      # For example, given the following class:
+      #
+      #   class Root < Alchemrest::Root
+      #     define_request :get_profile, Requests::GetProfile
+      #   end
+      #
+      # This compiler will generate an RBI file `root.rbi` with the following content:
+      #
+      #   sig { params(params: T::Hash[Symbol, T.untyped]).returns(::Alchemrest::Result[::Profile]) }
+      #   def get_profile(params = {}); end
+      #
+      class AlchemrestRoot < Tapioca::Dsl::Compiler
+        extend T::Sig
+
+        ConstantType = type_member { { upper: T.class_of(Alchemrest::Root) } }
+
+        sig { override.returns(T::Enumerable[Module]) }
+        def self.gather_constants
+          descendants_of(Alchemrest::Root)
+        end
+
+        sig { override.void }
+        def decorate
+          root.create_path(constant) do |rbi|
+            constant.request_definitions.each do |name, definition|
+              rbi.create_method(
+                name.to_s,
+                parameters: [create_opt_param('params', type: 'T::Hash[Symbol, T.untyped]', default: '{}')],
+                return_type: return_type_for(definition),
+              )
+            end
+          end
+        end
+
+        private
+
+        sig { params(definition: Alchemrest::RequestDefinition).returns(String) }
+        def return_type_for(definition)
+          transform = extract_transform(definition)
+
+          if transform.nil? || !transform.respond_to?(:output_type)
+            '::Alchemrest::Result[T.untyped]'
+          else
+            "::Alchemrest::Result[#{transform.output_type.sorbet_type}]"
+          end
+        end
+
+        sig { params(definition: Alchemrest::RequestDefinition).returns(T.nilable(Alchemrest::Transforms::Typed)) }
+        def extract_transform(definition)
+          request_class = definition.instance_variable_get(:@request_class)
+          returns_modules = request_class.ancestors.grep(Alchemrest::Request::Returns)
+          returns_modules.sole.domain_type.const_get(:TRANSFORM) if returns_modules.one?
+        end
+      end
+    end
+  end
+end