steam_api_client 0.10.0 → 1.0.0

data/lib/steam_api_client/client.rb

@@ -27,57 +27,59 @@ module SteamApiClient
   # https://store.steampowered.com/api/<method>?appids=1,2,3&filters=basic,recommendations
   # For more information, vist: https://wiki.teamfortress.com/wiki/User:RJackson/StorefrontAPI
   class Client
-    extend ::Dry::Configurable
-
     BASE_ENDPOINT = "https://api.steampowered.com"
     STOREFRONT_API_ENDPOINT = "https://store.steampowered.com/api/"
-    DEFAULT_TIMEOUT = 10
-    DEFAULT_CONNECT_TIMEOUT = 5
+    DEFAULT_TIMEOUT = Configuration::DEFAULT_TIMEOUT
+    DEFAULT_CONNECT_TIMEOUT = Configuration::DEFAULT_CONNECT_TIMEOUT
+    DEFAULT_ADAPTER = Configuration::DEFAULT_ADAPTER
+
+    # Built eagerly, so threads never race to create it
+    @config = Configuration.new
+
+    class << self
+      # The global settings shared by every client
+      # @return [SteamApiClient::Configuration]
+      attr_reader :config
 
-    setting :api_token
-    # Maximum time, in seconds, for the whole request
-    setting :timeout, default: DEFAULT_TIMEOUT
-    # Maximum time, in seconds, to establish the connection
-    setting :connect_timeout, default: DEFAULT_CONNECT_TIMEOUT
+      # SteamApiClient::Client.configure { |config| config.api_token = "..." }
+      # @yieldparam [SteamApiClient::Configuration] config
+      # @return [Class] the client class
+      def configure
+        yield config
+        self
+      end
+
+      # Restores the default settings (e.g. between specs)
+      # @return [SteamApiClient::Configuration]
+      def reset_config!
+        @config = Configuration.new
+      end
+    end
 
     attr_writer :api_token, :timeout, :connect_timeout
 
-    attr_reader \
-      :app_details,
-      :app_global_achievements,
-      :app_news,
-      :game_current_players,
-      :player_achievements,
-      :player_friends,
-      :player_game_stats,
-      :player_level,
-      :player_owned_games,
-      :player_recent_games,
-      :player_steamid,
-      :player_summaries
+    # One method per endpoint, e.g. client.player_level.retrieve(steamid: ...)
+    # @see SteamApiClient::Endpoints
+    Endpoints::ALL.each_key do |name|
+      define_method(name) { @requestors.fetch(name) }
+    end
 
     # Initialize the client
     # @param [String] api_token - An existing api token.
     # @param [Numeric] timeout - Request timeout in seconds. Defaults to the configured value.
     # @param [Numeric] connect_timeout - Connection timeout in seconds. Defaults to the configured value.
+    # @param [Symbol] adapter - Faraday adapter. Defaults to the configured value (:net_http).
+    # @yieldparam [Faraday::Connection] faraday - Customizes this client's connection (middleware,
+    #   adapter options...), after the global 'config.connection' block.
     # @return [SteamApiClient::Client] - A new class instance.
-    def initialize(api_token: nil, timeout: nil, connect_timeout: nil)
+    def initialize(api_token: nil, timeout: nil, connect_timeout: nil, adapter: nil, &connection_block)
       @api_token = api_token
       @timeout = timeout
       @connect_timeout = connect_timeout
+      @adapter = adapter
+      @connection_block = connection_block
 
-      @app_details ||= SteamApiClient::Requestors::AppDetails.new(self)
-      @app_global_achievements ||= SteamApiClient::Requestors::AppGlobalAchievements.new(self)
-      @app_news ||= SteamApiClient::Requestors::AppNews.new(self)
-      @game_current_players ||= SteamApiClient::Requestors::GameCurrentPlayers.new(self)
-      @player_achievements ||= SteamApiClient::Requestors::PlayerAchievements.new(self)
-      @player_friends ||= SteamApiClient::Requestors::PlayerFriends.new(self)
-      @player_game_stats ||= SteamApiClient::Requestors::PlayerGameStats.new(self)
-      @player_level ||= SteamApiClient::Requestors::PlayerLevel.new(self)
-      @player_owned_games ||= SteamApiClient::Requestors::PlayerOwnedGames.new(self)
-      @player_recent_games ||= SteamApiClient::Requestors::PlayerRecentGames.new(self)
-      @player_steamid ||= SteamApiClient::Requestors::PlayerSteamId.new(self)
-      @player_summaries ||= SteamApiClient::Requestors::PlayerSummaries.new(self)
+      @requestors = Endpoints::ALL.transform_values { |endpoint| Requestor.new(self, endpoint) }
     end
 
     # The token sent on authorized requests. Falls back to the value set
@@ -97,10 +99,31 @@ module SteamApiClient
       @connect_timeout || config.connect_timeout
     end
 
+    # @return [Symbol] the Faraday adapter used for the requests
+    def adapter
+      @adapter || config.adapter
+    end
+
+    # The Faraday connection shared by this client's requests: the adapter, then
+    # the global 'config.connection' block, then the block given to Client.new
+    # @return [Faraday::Connection]
+    def connection
+      @connection ||= ::Faraday.new do |faraday|
+        faraday.adapter(adapter)
+        [config.connection, @connection_block].compact.each { |block| block.call(faraday) }
+      end
+    end
+
     def config
       self.class.config
     end
 
+    # Keeps the token out of logs, consoles and error trackers
+    # @return [String]
+    def inspect
+      Configuration.inspect_settings(self)
+    end
+
     def base_endpoint
       BASE_ENDPOINT
     end

data/lib/steam_api_client/configuration.rb

@@ -0,0 +1,55 @@
+module SteamApiClient
+  # Global defaults for every Client, set with 'SteamApiClient::Client.configure'.
+  # Values given to Client.new override them.
+  class Configuration
+    DEFAULT_TIMEOUT = 10
+    DEFAULT_CONNECT_TIMEOUT = 5
+    DEFAULT_ADAPTER = :net_http
+
+    # Steam Web API token, sent on the endpoints that need one
+    attr_accessor :api_token
+    # Maximum time, in seconds, for the whole request
+    attr_accessor :timeout
+    # Maximum time, in seconds, to establish the connection
+    attr_accessor :connect_timeout
+    # Faraday adapter used for the requests, e.g. :net_http (default) or any
+    # adapter gem the app installs
+    attr_accessor :adapter
+
+    def initialize
+      @api_token = nil
+      @timeout = DEFAULT_TIMEOUT
+      @connect_timeout = DEFAULT_CONNECT_TIMEOUT
+      @adapter = DEFAULT_ADAPTER
+      @connection = nil
+    end
+
+    # Customizes the Faraday connection of every client (middleware, adapter
+    # options...). It runs after the adapter is set, so it can replace it.
+    #   config.connection { |faraday| faraday.request :retry }
+    # @yieldparam [Faraday::Connection] faraday
+    # @return [Proc, nil] the block, when called without one
+    def connection(&block)
+      block ? @connection = block : @connection
+    end
+
+    # @return [Hash]
+    def to_h
+      {api_token: api_token, timeout: timeout, connect_timeout: connect_timeout, adapter: adapter}
+    end
+
+    # Keeps the token out of logs, consoles and error trackers
+    # @return [String]
+    def inspect
+      self.class.inspect_settings(self)
+    end
+
+    # The settings of a Configuration or a Client, with the token redacted
+    # @return [String]
+    def self.inspect_settings(object)
+      token = object.api_token.nil? ? "nil" : "[REDACTED]"
+      settings = "timeout=#{object.timeout} connect_timeout=#{object.connect_timeout} adapter=#{object.adapter.inspect}"
+      "#<#{object.class.name} api_token=#{token} #{settings}>"
+    end
+  end
+end

data/lib/steam_api_client/endpoint/param.rb

@@ -0,0 +1,83 @@
+module SteamApiClient
+  class Endpoint
+    # A query param: checks and converts the value given to #retrieve
+    class Param
+      TYPES = %i[integer integer_list string string_list boolean].freeze
+      NO_DEFAULT = Object.new.freeze
+      private_constant :NO_DEFAULT
+
+      attr_reader :type, :as, :default, :allowed
+
+      TYPES.each do |type|
+        define_singleton_method(type) { |**options| new(type, **options) }
+      end
+
+      # @param [Symbol] type one of TYPES
+      # @param [Symbol, nil] as the name Steam uses for the param, when it differs
+      # @param default the value used when the keyword isn't given. Without one, the keyword is required.
+      # @param [Array, nil] in the only values allowed
+      def initialize(type, as: nil, default: NO_DEFAULT, in: nil)
+        raise ArgumentError, "type must be one of #{TYPES.inspect}, got #{type.inspect}" unless TYPES.include?(type)
+
+        @type = type
+        @as = as
+        @default = default
+        @allowed = binding.local_variable_get(:in)
+        freeze
+      end
+
+      def required?
+        default.equal?(NO_DEFAULT)
+      end
+
+      # @return the value as sent to Steam
+      # @raise [ArgumentError] if the value has the wrong type or isn't allowed
+      def convert(name, value)
+        converted = send(:"convert_#{type}", name, value)
+        return converted if allowed.nil? || allowed.include?(converted)
+
+        raise ArgumentError, "#{name} must be one of #{allowed.map(&:inspect).join(", ")}, got #{value.inspect}"
+      end
+
+      private
+
+      def convert_integer(name, value)
+        return value if value.is_a?(::Integer)
+        return Integer(value, 10) if value.is_a?(::String) && value.match?(/\A-?\d+\z/)
+
+        invalid(name, "an Integer", value)
+      end
+
+      def convert_string(name, value)
+        return value.to_s if value.is_a?(::String) || value.is_a?(::Symbol)
+
+        invalid(name, "a String", value)
+      end
+
+      def convert_boolean(name, value)
+        return value if value == true || value == false
+
+        invalid(name, "true or false", value)
+      end
+
+      # Lists are sent comma-separated
+      def convert_integer_list(name, value)
+        list(name, value) { |item| convert_integer(name, item) }
+      end
+
+      def convert_string_list(name, value)
+        list(name, value) { |item| convert_string(name, item) }
+      end
+
+      def list(name, value, &)
+        invalid(name, "an Array", value) unless value.is_a?(::Array)
+
+        value.map(&).join(",")
+      end
+
+      def invalid(name, expected, value)
+        raise ArgumentError, "#{name} must be #{expected}, got #{value.inspect}"
+      end
+    end
+  end
+end

data/lib/steam_api_client/endpoint.rb

@@ -0,0 +1,90 @@
+module SteamApiClient
+  # One Steam endpoint, declared in SteamApiClient::Endpoints. Turns the keyword
+  # arguments given to its requestor's #retrieve into the request's query params.
+  class Endpoint
+    APIS = %i[web store].freeze
+
+    # Reads the value at a path of keys, nil when a key is missing
+    class KeyPath
+      def initialize(keys)
+        @keys = keys.dup.freeze
+        freeze
+      end
+
+      # @raise [Model::Error] when the path goes through something that isn't an object
+      def call(json)
+        @keys.reduce(json) do |object, key|
+          raise Model::Error, "expected an object at #{key.inspect}, got #{object.class}" unless object.nil? || object.is_a?(Hash)
+
+          object&.[](key)
+        end
+      end
+    end
+
+    attr_reader :name, :path, :api, :params, :returns, :at
+
+    # @param [Symbol] name the client method, e.g. :player_level
+    # @param [String] path Web API: "<interface>/<method>/<version>/"; Storefront: "<method>/"
+    # @param returns what #retrieve returns, as a Model type: a model, [model] for a list, or :integer
+    # @param [Array<Symbol>, #call] at where the result is in Steam's JSON: a path of keys, or a callable
+    #   that takes the JSON (the result is nil when a key is missing)
+    # @param [Symbol] api :web (api.steampowered.com) or :store (store.steampowered.com/api)
+    # @param [Boolean] key whether Steam needs the API key
+    # @param [Hash{Symbol => Param}] params the keyword arguments of #retrieve, in query order
+    def initialize(name, path, returns:, at: [], api: :web, key: true, params: {})
+      raise ArgumentError, "api must be :web or :store, got #{api.inspect}" unless APIS.include?(api)
+
+      @name = name
+      @path = path.freeze
+      @returns = returns
+      @at = at.respond_to?(:call) ? at : KeyPath.new(at)
+      @api = api
+      @key = key
+      @params = params.freeze
+      freeze
+    end
+
+    def key?
+      @key
+    end
+
+    # The query params for the given keyword arguments, with defaults applied
+    # @param [Hash] arguments the keyword arguments given to #retrieve
+    # @return [Hash] params named as Steam expects them, in declaration order
+    # @raise [ArgumentError] on missing or unknown keywords, and invalid values
+    def query(arguments)
+      check_keywords(arguments)
+
+      params.each_with_object({}) do |(name, param), query|
+        query[param.as || name] = param.convert(name, arguments.fetch(name) { param.default })
+      end
+    end
+
+    # The result of a call, from Steam's JSON. Steam answers with an empty object when
+    # the data isn't visible (e.g. a private profile), which is nil, or [] for lists.
+    # @param [Hash] json the parsed response body, with symbol keys
+    # @raise [Model::Error] if the JSON doesn't match the result's type
+    def result(json)
+      value = at.call(json)
+      value = nil if value == {}
+      return [] if value.nil? && returns.is_a?(Array)
+
+      Model.cast(returns, value)
+    end
+
+    private
+
+    # Same errors, and messages, as Ruby's own keyword arguments
+    def check_keywords(arguments)
+      missing = params.select { |name, param| param.required? && !arguments.key?(name) }.keys
+      raise ArgumentError, keyword_error("missing", missing) if missing.any?
+
+      unknown = arguments.keys - params.keys
+      raise ArgumentError, keyword_error("unknown", unknown) if unknown.any?
+    end
+
+    def keyword_error(kind, names)
+      "#{kind} keyword#{"s" if names.size > 1}: #{names.map(&:inspect).join(", ")}"
+    end
+  end
+end

data/lib/steam_api_client/endpoints.rb

@@ -0,0 +1,122 @@
+module SteamApiClient
+  # Every endpoint the client exposes, as `client.<name>.retrieve(**params)`, and
+  # what it returns (see SteamApiClient::Model for the models).
+  #
+  # Web API paths are "<interface>/<method>/<version>/" under https://api.steampowered.com.
+  # Storefront paths (`api: :store`) are relative to https://store.steampowered.com/api/,
+  # Steam's unofficial store API.
+  #
+  # To add an endpoint, declare it here, with its model when it returns one.
+  module Endpoints
+    param = Endpoint::Param
+
+    ALL = [
+      # Details of an app in the store => AppDetails, or nil when the app is unavailable
+      # @see https://wiki.teamfortress.com/wiki/User:RJackson/StorefrontAPI#appdetails
+      Endpoint.new(
+        :app_details, "appdetails/", api: :store, key: false, returns: AppDetails, at: AppDetails.method(:unwrap),
+        params: {
+          appid: param.integer(as: :appids),
+          # e.g. ["basic", "price_overview"]; every field when empty
+          filters: param.string_list(default: []),
+          # Country code for the prices
+          country_code: param.string(as: :cc, default: "US"),
+          # Language of the texts
+          locale: param.string(as: :l, default: "en")
+        }
+      ),
+
+      # Global achievement unlock percentages of an app => [GlobalAchievement]
+      # @see https://developer.valvesoftware.com/wiki/Steam_Web_API#GetGlobalAchievementPercentagesForApp_.28v0002.29
+      Endpoint.new(
+        :app_global_achievements, "ISteamUserStats/GetGlobalAchievementPercentagesForApp/v0002/",
+        key: false, returns: [GlobalAchievement], at: %i[achievementpercentages achievements],
+        params: {appid: param.integer(as: :gameid)}
+      ),
+
+      # Latest news of an app => [NewsItem]
+      # @see https://developer.valvesoftware.com/wiki/Steam_Web_API#GetNewsForApp_.28v0002.29
+      Endpoint.new(
+        :app_news, "ISteamNews/GetNewsForApp/v0002/", key: false, returns: [NewsItem], at: %i[appnews newsitems],
+        params: {
+          appid: param.integer,
+          # Number of news items
+          count: param.integer,
+          # Maximum length of each item's contents
+          maxlength: param.integer(default: 300)
+        }
+      ),
+
+      # Number of players currently in a game => Integer
+      # @see https://wiki.teamfortress.com/wiki/WebAPI/GetNumberOfCurrentPlayers
+      Endpoint.new(
+        :game_current_players, "ISteamUserStats/GetNumberOfCurrentPlayers/v0001/",
+        key: false, returns: :integer, at: %i[response player_count],
+        params: {appid: param.integer}
+      ),
+
+      # A player's achievements in an app => PlayerAchievements
+      # @see https://developer.valvesoftware.com/wiki/Steam_Web_API#GetPlayerAchievements_.28v0001.29
+      Endpoint.new(
+        :player_achievements, "ISteamUserStats/GetPlayerAchievements/v0001/", returns: PlayerAchievements, at: %i[playerstats],
+        params: {appid: param.integer, steamid: param.integer}
+      ),
+
+      # A player's friend list, if public => [Friend]
+      # @see https://developer.valvesoftware.com/wiki/Steam_Web_API#GetFriendList_.28v0001.29
+      Endpoint.new(
+        :player_friends, "ISteamUser/GetFriendList/v0001/", returns: [Friend], at: %i[friendslist friends],
+        params: {steamid: param.integer, relationship: param.string(default: "all", in: %w[all friend])}
+      ),
+
+      # A player's stats and achievements in a game => PlayerGameStats
+      # @see https://developer.valvesoftware.com/wiki/Steam_Web_API#GetUserStatsForGame_.28v0002.29
+      Endpoint.new(
+        :player_game_stats, "ISteamUserStats/GetUserStatsForGame/v0002/", returns: PlayerGameStats, at: %i[playerstats],
+        params: {appid: param.integer, steamid: param.integer}
+      ),
+
+      # A player's Steam level => Integer, or nil when the profile isn't visible
+      # @see https://wiki.teamfortress.com/wiki/WebAPI/GetSteamLevel
+      Endpoint.new(
+        :player_level, "IPlayerService/GetSteamLevel/v0001/", returns: :integer, at: %i[response player_level],
+        params: {steamid: param.integer}
+      ),
+
+      # The games a player owns => OwnedGames, or nil when the library isn't public
+      # @see https://developer.valvesoftware.com/wiki/Steam_Web_API#GetOwnedGames_.28v0001.29
+      Endpoint.new(
+        :player_owned_games, "IPlayerService/GetOwnedGames/v0001/", returns: OwnedGames, at: %i[response],
+        params: {
+          steamid: param.integer,
+          # Include each game's name and icon
+          include_appinfo: param.boolean(default: false),
+          # Include free games the player has played
+          include_played_free_games: param.boolean(default: false)
+        }
+      ),
+
+      # The games a player played in the last two weeks => RecentGames, or nil when not public
+      # @see https://developer.valvesoftware.com/wiki/Steam_Web_API#GetRecentlyPlayedGames_.28v0001.29
+      Endpoint.new(
+        :player_recent_games, "IPlayerService/GetRecentlyPlayedGames/v0001/", returns: RecentGames, at: %i[response],
+        params: {steamid: param.integer, count: param.integer(default: 5)}
+      ),
+
+      # The 64 bit Steam ID a vanity URL (steamcommunity.com/id/<vanityurl>) resolves to
+      # => Integer, or nil when nothing matches
+      # @see https://wiki.teamfortress.com/wiki/WebAPI/ResolveVanityURL
+      Endpoint.new(
+        :player_steamid, "ISteamUser/ResolveVanityURL/v0001/", returns: :integer, at: %i[response steamid],
+        params: {vanityurl: param.string}
+      ),
+
+      # Profile summaries of up to 100 players => [PlayerSummary] (unknown IDs are left out)
+      # @see https://developer.valvesoftware.com/wiki/Steam_Web_API#GetPlayerSummaries_.28v0002.29
+      Endpoint.new(
+        :player_summaries, "ISteamUser/GetPlayerSummaries/v0002/", returns: [PlayerSummary], at: %i[response players],
+        params: {steamids: param.integer_list}
+      )
+    ].to_h { |endpoint| [endpoint.name, endpoint] }.freeze
+  end
+end

data/lib/steam_api_client/errors/api_error.rb

@@ -4,15 +4,17 @@ module SteamApiClient
     #
     class ApiError < ::StandardError
       # Initializes a request API custom error
-      # @param [SteamApiClient::Response] Http response wrapper
+      # @param [SteamApiClient::Response, nil] response Http response wrapper, nil when
+      #   the request failed without one (e.g. it timed out)
+      # @param [String, nil] message Overrides the message built from the response
       # @return A new instance of ApiError
       #
-      def initialize(response)
-        @http_status_code = response.status_code
+      def initialize(response = nil, message = nil)
+        @http_status_code = response&.status_code
         @response = response
-        @request = response.request
+        @request = response&.request
 
-        super(build_description_message)
+        super(message || build_description_message)
       end
 
       private
@@ -27,6 +29,9 @@ module SteamApiClient
       end
     end
 
+    # Raised when the request times out (no response), or when Steam answers 408
+    class HttpTimeout < ApiError; end
+
     # status_code: 400
     class HttpBadRequest < ApiError; end
 
@@ -39,9 +44,6 @@ module SteamApiClient
     # status_code: 404
     class HttpNotFound < ApiError; end
 
-    # status_code: 408
-    class HttpTimeout < ApiError; end
-
     # status_code: 500
     class HttpInternalServerError < ApiError; end
 

data/lib/steam_api_client/errors/connection_error.rb

@@ -0,0 +1,7 @@
+module SteamApiClient
+  module Errors
+    # Raised when Steam can't be reached at all (DNS failure, refused connection,
+    # TLS error), so there is no HTTP response. The adapter's error is #cause.
+    class ConnectionError < ::StandardError; end
+  end
+end

data/lib/steam_api_client/errors/response_parse_error.rb

@@ -1,18 +1,18 @@
 module SteamApiClient
   module Errors
-    # Raised when an API response can't be built into its response struct,
-    # e.g. the body isn't a JSON object or doesn't match the struct's schema.
-    # The underlying JSON or Dry::Struct error is available through #cause.
+    # Raised when an API response can't be read into the endpoint's result,
+    # e.g. the body isn't a JSON object or doesn't match the result's model.
+    # The underlying JSON or SteamApiClient::Model::Error is available through #cause.
     class ResponseParseError < ::StandardError
       attr_reader :response
 
       # @param [SteamApiClient::Response] response Http response wrapper
-      # @param [Class] response_struct The struct the response was built into
+      # @param [SteamApiClient::Endpoint] endpoint The endpoint called
       # @return A new instance of ResponseParseError
-      def initialize(response, response_struct)
+      def initialize(response, endpoint)
         @response = response
 
-        super("Unable to build #{response_struct} from the API response (status code: #{response.status_code})")
+        super("Unable to read the #{endpoint.name} result from the API response (status code: #{response.status_code})")
       end
     end
   end

data/lib/steam_api_client/failure_handler.rb

@@ -10,8 +10,6 @@ module SteamApiClient
     def call(response)
       return unless response.fail?
 
-      raise_timedout(response) if response.timed_out?
-
       raise_response_4xx(response) if (400..499).cover?(response.status_code)
       raise_response_5xx(response) if (500..599).cover?(response.status_code)
 
@@ -20,16 +18,13 @@ module SteamApiClient
 
     private
 
-    def raise_timedout(response)
-      raise SteamApiClient::Errors::HttpTimeout, response
-    end
-
     def raise_response_4xx(response)
       case response.status_code
       when 400 then raise SteamApiClient::Errors::HttpBadRequest, response
       when 401 then raise SteamApiClient::Errors::HttpUnauthorized, response
       when 403 then raise SteamApiClient::Errors::HttpForbidden, response
       when 404 then raise SteamApiClient::Errors::HttpNotFound, response
+      when 408 then raise SteamApiClient::Errors::HttpTimeout, response
       when 429 then raise SteamApiClient::Errors::HttpTooManyRequests, response
       end
     end

data/lib/steam_api_client/model/field.rb

@@ -0,0 +1,42 @@
+module SteamApiClient
+  module Model
+    # One field of a model: where to read it in Steam's JSON and how to convert it
+    class Field
+      MISSING = Object.new.freeze
+      private_constant :MISSING
+
+      attr_reader :name, :type
+
+      def initialize(name, type, from: name, optional: false, default: nil)
+        @name = name
+        @type = type
+        @path = Array(from)
+        @optional = optional || !default.nil?
+        @default = default.frozen? ? default : default.dup.freeze
+      end
+
+      # @param [Hash] json the model's JSON object
+      # @return the converted value
+      # @raise [Model::Error] naming the field
+      def read(json)
+        value = dig(json)
+        raise Error, "missing key #{@path.last.inspect}" if value.equal?(MISSING) && !@optional
+        return @default if value.equal?(MISSING) || value.nil?
+
+        Model.cast(type, value)
+      rescue Error => error
+        raise Error, "#{name}: #{error.message}"
+      end
+
+      private
+
+      def dig(json)
+        @path.reduce(json) do |object, key|
+          return MISSING unless object.is_a?(Hash) && object.key?(key)
+
+          object[key]
+        end
+      end
+    end
+  end
+end