# frozen_string_literal: truemoduleGraphQLclassQuery# Read-only access to values, normalizing all keys to strings## {Arguments} recursively wraps the input in {Arguments} instances.classArgumentsextendForwardableincludeGraphQL::Digdefself.construct_arguments_class(argument_owner)argument_definitions=argument_owner.argumentsargument_owner.arguments_class=Class.new(self)doself.argument_definitions=argument_definitionsargument_definitions.eachdo|_arg_name,arg_definition|ifarg_definition.method_access?expose_as=arg_definition.expose_as.to_s.freezeexpose_as_underscored=GraphQL::Schema::Member::BuildType.underscore(expose_as).freezemethod_names=[expose_as,expose_as_underscored].uniqmethod_names.eachdo|method_name|# Don't define a helper method if it would override something.ifmethod_defined?(method_name)warn("Unable to define a helper for argument with name '#{method_name}' "\"as this is a reserved name. Add `method_access: false` to stop this warning.")elsedefine_method(method_name)do# Always use `expose_as` here, since #[] doesn't accept underscored namesself[expose_as]endendendendendendendattr_reader:argument_valuesdefinitialize(values,context:,defaults_used:)@argument_values=values.inject({})do|memo,(inner_key,inner_value)|arg_name=inner_key.to_sarg_defn=self.class.argument_definitions[arg_name]||raise("Not found #{arg_name} among #{self.class.argument_definitions.keys}")arg_default_used=defaults_used.include?(arg_name)arg_value=wrap_value(inner_value,arg_defn.type,context)string_key=arg_defn.expose_asmemo[string_key]=ArgumentValue.new(string_key,arg_value,arg_defn,arg_default_used)memoendend# @param key [String, Symbol] name or index of value to access# @return [Object] the argument at that keydef[](key)key_s=key.is_a?(String)?key:key.to_s@argument_values.fetch(key_s,NULL_ARGUMENT_VALUE).valueend# @param key [String, Symbol] name of value to access# @return [Boolean] true if the argument was present in this fielddefkey?(key)key_s=key.is_a?(String)?key:key.to_s@argument_values.key?(key_s)end# @param key [String, Symbol] name of value to access# @return [Boolean] true if the argument default was passed as the argument value to the resolverdefdefault_used?(key)key_s=key.is_a?(String)?key:key.to_s@argument_values.fetch(key_s,NULL_ARGUMENT_VALUE).default_used?end# Get the hash of all values, with stringified keys# @return [Hash] the stringified hashdefto_h@to_h||=beginh={}each_valuedo|arg_value|arg_key=arg_value.definition.expose_ash[arg_key]=unwrap_value(arg_value.value)endhendenddef_delegators:to_h,:keys,:values,:each,:any?defprepareselfend# Access each key, value and type for the arguments in this set.# @yield [argument_value] The {ArgumentValue} for each argument# @yieldparam argument_value [ArgumentValue]defeach_value@argument_values.each_valuedo|argument_value|yield(argument_value)endendclass<<selfattr_accessor:argument_definitionsendNoArguments=Class.new(self)doself.argument_definitions=[]endNO_ARGS=NoArguments.new({},context: nil,defaults_used: Set.new)# Convert this instance into valid Ruby keyword arguments# @return [{Symbol=>Object}]defto_kwargsruby_kwargs={}keys.eachdo|key|ruby_kwargs[Schema::Member::BuildType.underscore(key).to_sym]=self[key]endruby_kwargsendalias:to_hash:to_kwargsprivateclassArgumentValueattr_reader:key,:value,:definitionattr_writer:default_useddefinitialize(key,value,definition,default_used)@key=key@value=value@definition=definition@default_used=default_usedend# @return [Boolean] true if the argument default was passed as the argument value to the resolverdefdefault_used?@default_usedendendNULL_ARGUMENT_VALUE=ArgumentValue.new(nil,nil,nil,nil)defwrap_value(value,arg_defn_type,context)ifvalue.nil?nilelsecasearg_defn_typewhenGraphQL::ListTypevalue.map{|item|wrap_value(item,arg_defn_type.of_type,context)}whenGraphQL::NonNullTypewrap_value(value,arg_defn_type.of_type,context)whenGraphQL::InputObjectTypeifvalue.is_a?(Hash)result=arg_defn_type.arguments_class.new(value,context: context,defaults_used: Set.new)result.prepareelsevalueendelsevalueendendenddefunwrap_value(value)casevaluewhenArrayvalue.map{|item|unwrap_value(item)}whenHashvalue.inject({})do|memo,(key,value)|memo[key]=unwrap_value(value)memoendwhenGraphQL::Query::Arguments,GraphQL::Schema::InputObjectvalue.to_helsevalueendendendendend