Analyze a multiplex, and all queries within.
+Multiplex analyzers are ran for all queries, keeping state.
+Query analyzers are ran per query, without carrying state between queries.
# File 'lib/graphql/analysis/ast/field_usage.rb', line 13
+
+defon_leave_field(node,parent,visitor)
+ field_defn=visitor.field_definition
+ field="#{visitor.parent_type_definition.graphql_name}.#{field_defn.graphql_name}"
+ @used_fields<<field
+ @used_deprecated_fields<<fieldiffield_defn.deprecation_reason
+ arguments=visitor.query.arguments_for(node,visitor.field_definition)
+ # If there was an error when preparing this argument object,
+# then this might be an error or something:
+ifarguments.respond_to?(:argument_values)
+ extract_deprecated_arguments(arguments.argument_values)
+ end
+end
# File 'lib/graphql/analysis/ast/max_query_complexity.rb', line 8
+
+defresult
+ returnifsubject.max_complexity.nil?
+
+ total_complexity=max_possible_complexity
+
+ iftotal_complexity>subject.max_complexity
+ GraphQL::AnalysisError.new("Query has complexity of #{total_complexity}, which exceeds max complexity of #{subject.max_complexity}")
+ else
+ nil
+ end
+end
+
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/api-doc/2.1.6/GraphQL/Analysis/AST/MaxQueryDepth.html b/api-doc/2.1.6/GraphQL/Analysis/AST/MaxQueryDepth.html
new file mode 100644
index 0000000000..622da5585c
--- /dev/null
+++ b/api-doc/2.1.6/GraphQL/Analysis/AST/MaxQueryDepth.html
@@ -0,0 +1,243 @@
+
+
+
+
+
+
+ Class: GraphQL::Analysis::AST::MaxQueryDepth
+
+ — GraphQL Ruby API Documentation
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
# File 'lib/graphql/analysis/ast/max_query_depth.rb', line 6
+
+defresult
+ configured_max_depth=ifquery
+ query.max_depth
+ else
+ multiplex.schema.max_depth
+ end
+
+ ifconfigured_max_depth&&@max_depth>configured_max_depth
+ GraphQL::AnalysisError.new("Query has depth of #{@max_depth}, which exceeds max depth of #{configured_max_depth}")
+ else
+ nil
+ end
+end
+
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/api-doc/2.1.6/GraphQL/Analysis/AST/QueryComplexity.html b/api-doc/2.1.6/GraphQL/Analysis/AST/QueryComplexity.html
new file mode 100644
index 0000000000..d61ae8f3fc
--- /dev/null
+++ b/api-doc/2.1.6/GraphQL/Analysis/AST/QueryComplexity.html
@@ -0,0 +1,452 @@
+
+
+
+
+
+
+ Class: GraphQL::Analysis::AST::QueryComplexity
+
+ — GraphQL Ruby API Documentation
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
# File 'lib/graphql/analysis/ast/query_complexity.rb', line 61
+
+defon_enter_field(node,parent,visitor)
+ # We don't want to visit fragment definitions,
+# we'll visit them when we hit the spreads instead
+returnifvisitor.visiting_fragment_definition?
+ returnifvisitor.skipping?
+ parent_type=visitor.parent_type_definition
+ field_key=node.alias||node.name
+ # Find the complexity calculation for this field --
+# if we're re-entering a selection, we'll already have one.
+# Otherwise, make a new one and store it.
+#
+# `node` and `visitor.field_definition` may appear from a cache,
+# but I think that's ok. If the arguments _didn't_ match,
+# then the query would have been rejected as invalid.
+complexities_on_type=@complexities_on_type_by_query[visitor.query]||=[ScopedTypeComplexity.new(nil,nil,query,visitor.response_path)]
+
+ complexity=complexities_on_type.last.scoped_children[parent_type][field_key]||=ScopedTypeComplexity.new(parent_type,visitor.field_definition,visitor.query,visitor.response_path)
+ complexity.nodes.push(node)
+ # Push it on the stack.
+complexities_on_type.push(complexity)
+end
# File 'lib/graphql/analysis/ast/query_complexity.rb', line 83
+
+defon_leave_field(node,parent,visitor)
+ # We don't want to visit fragment definitions,
+# we'll visit them when we hit the spreads instead
+returnifvisitor.visiting_fragment_definition?
+ returnifvisitor.skipping?
+ complexities_on_type=@complexities_on_type_by_query[visitor.query]
+ complexities_on_type.pop
+end
+
+
+
+
+
+
+
+
+ #result ⇒ Object
+
+
+
+
+
+
+
+
Overide this method to use the complexity result
+
+
+
+
+
+
+
+
+
+
+
+
+
+15
+16
+17
+
+
+
# File 'lib/graphql/analysis/ast/query_complexity.rb', line 15
+
+defresult
+ max_possible_complexity
+end
+
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/api-doc/2.1.6/GraphQL/Analysis/AST/QueryComplexity/ScopedTypeComplexity.html b/api-doc/2.1.6/GraphQL/Analysis/AST/QueryComplexity/ScopedTypeComplexity.html
new file mode 100644
index 0000000000..37392e5f9d
--- /dev/null
+++ b/api-doc/2.1.6/GraphQL/Analysis/AST/QueryComplexity/ScopedTypeComplexity.html
@@ -0,0 +1,823 @@
+
+
+
+
+
+
+ Class: GraphQL::Analysis::AST::QueryComplexity::ScopedTypeComplexity
+
+ — GraphQL Ruby API Documentation
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
This value is only calculated when asked for to avoid needless hash allocations.
+Also, if it’s never asked for, we determine that this scope complexity
+is a scalar field (#terminal?).
Depth first traversal through a query AST, calling AST analyzers
+along the way.
+
+
The visitor is a special case of GraphQL::Language::StaticVisitor, visiting
+only the selected operation, providing helpers for common use cases such
+as skipped fields and visiting fragment spreads.
# File 'lib/graphql/backtrace/trace.rb', line 12
+
+defanalyze_query(query:)
+ ifquery.multiplex# missing for stand-alone static validation
+push_query_backtrace_context(query)
+ end
+ super
+end
# File 'lib/graphql/backtrace/trace.rb', line 40
+
+defexecute_multiplex(multiplex:)
+ super
+rescueStandardError=>err
+ # This is an unhandled error from execution,
+# Re-raise it with a GraphQL trace.
+multiplex_context=multiplex.context
+ potential_context=multiplex_context[:last_graphql_backtrace_context]
+
+ ifpotential_context.is_a?(GraphQL::Query::Context)||
+ potential_context.is_a?(Backtrace::Frame)
+ raiseTracedError.new(err,potential_context)
+ else
+ raise
+ end
+ensure
+ multiplex_context=multiplex.context
+ multiplex_context.delete(:graphql_backtrace_contexts)
+ multiplex_context.delete(:last_graphql_backtrace_context)
+end
+
+
+
+
+
+
+
+
+ #execute_query(query:) ⇒ Object
+
+
+
+
+
+
+
+
+
+
+
+19
+20
+21
+22
+
+
+
# File 'lib/graphql/backtrace/trace.rb', line 19
+
+defexecute_query(query:)
+ push_query_backtrace_context(query)
+ super
+end
# File 'lib/graphql/dataloader.rb', line 126
+
+defappend_job(&job)
+ # Given a block, queue it up to be worked through when `#run` is called.
+# (If the dataloader is already running, than a Fiber will pick this up later.)
+@pending_jobs.push(job)
+ nil
+end
+
+
+
+
+
+
+
+
+ #clear_cache ⇒ void
+
+
+
+
+
+
+
+
This method returns an undefined value.
Clear any already-loaded objects from Source caches
+
+
+
+
+
+
+
+
+
+
+
+
+
+135
+136
+137
+138
+139
+140
+
+
+
# File 'lib/graphql/dataloader.rb', line 135
+
+defclear_cache
+ @source_cache.eachdo|_source_class,batched_sources|
+ batched_sources.each_value(&:clear_cache)
+ end
+ nil
+end
This is called before the fiber is spawned, from the parent context (i.e. from
+the thread or fiber that it is scheduled from).
+
+
+
+
+
+
+
Returns:
+
+
+
+
+
+ (Hash<Symbol, Object>)
+
+
+
+ —
+
Current fiber-local variables
+
+
+
+
+
+
+
+
+
+
+
+
+68
+69
+70
+71
+72
+73
+74
+75
+76
+77
+
+
+
# File 'lib/graphql/dataloader.rb', line 68
+
+defget_fiber_variables
+ fiber_vars={}
+ Thread.current.keys.eachdo|fiber_var_key|
+ # This variable should be fresh in each new fiber
+iffiber_var_key!=:__graphql_runtime_info
+ fiber_vars[fiber_var_key]=Thread.current[fiber_var_key]
+ end
+ end
+ fiber_vars
+end
# File 'lib/graphql/dataloader.rb', line 171
+
+defrun
+ if@nonblocking&&!Fiber.scheduler
+ raise"`nonblocking: true` requires `Fiber.scheduler`, assign one with `Fiber.set_scheduler(...)` before executing GraphQL."
+ end
+ # At a high level, the algorithm is:
+#
+# A) Inside Fibers, run jobs from the queue one-by-one
+# - When one of the jobs yields to the dataloader (`Fiber.yield`), then that fiber will pause
+# - In that case, if there are still pending jobs, a new Fiber will be created to run jobs
+# - Continue until all jobs have been _started_ by a Fiber. (Any number of those Fibers may be waiting to be resumed, after their data is loaded)
+# B) Once all known jobs have been run until they are complete or paused for data, run all pending data sources.
+# - Similarly, create a Fiber to consume pending sources and tell them to load their data.
+# - If one of those Fibers pauses, then create a new Fiber to continue working through remaining pending sources.
+# - When a source causes another source to become pending, run the newly-pending source _first_, since it's a dependency of the previous one.
+# C) After all pending sources have been completely loaded (there are no more pending sources), resume any Fibers that were waiting for data.
+# - Those Fibers assume that source caches will have been populated with the data they were waiting for.
+# - Those Fibers may request data from a source again, in which case they will yeilded and be added to a new pending fiber list.
+# D) Once all pending fibers have been resumed once, return to `A` above.
+#
+# For whatever reason, the best implementation I could find was to order the steps `[D, A, B, C]`, with a special case for skipping `D`
+# on the first pass. I just couldn't find a better way to write the loops in a way that was DRY and easy to read.
+#
+pending_fibers=[]
+ next_fibers=[]
+ pending_source_fibers=[]
+ next_source_fibers=[]
+ first_pass=true
+
+ whilefirst_pass||(f=pending_fibers.shift)
+ iffirst_pass
+ first_pass=false
+ else
+ # These fibers were previously waiting for sources to load data,
+# resume them. (They might wait again, in which case, re-enqueue them.)
+resume(f)
+ iff.alive?
+ next_fibers<<f
+ end
+ end
+
+ while@pending_jobs.any?
+ # Create a Fiber to consume jobs until one of the jobs yields
+# or jobs run out
+f=spawn_fiber{
+ while(job=@pending_jobs.shift)
+ job.call
+ end
+ }
+ resume(f)
+ # In this case, the job yielded. Queue it up to run again after
+# we load whatever it's waiting for.
+iff.alive?
+ next_fibers<<f
+ end
+ end
+
+ ifpending_fibers.empty?
+ # Now, run all Sources which have become pending _before_ resuming GraphQL execution.
+# Sources might queue up other Sources, which is fine -- those will also run before resuming execution.
+#
+# This is where an evented approach would be even better -- can we tell which
+# fibers are ready to continue, and continue execution there?
+#
+if(first_source_fiber=create_source_fiber)
+ pending_source_fibers<<first_source_fiber
+ end
+
+ whilepending_source_fibers.any?
+ while(outer_source_fiber=pending_source_fibers.pop)
+ resume(outer_source_fiber)
+ ifouter_source_fiber.alive?
+ next_source_fibers<<outer_source_fiber
+ end
+ if(next_source_fiber=create_source_fiber)
+ pending_source_fibers<<next_source_fiber
+ end
+ end
+ join_queues(pending_source_fibers,next_source_fibers)
+ next_source_fibers.clear
+ end
+ # Move newly-enqueued Fibers on to the list to be resumed.
+# Clear out the list of next-round Fibers, so that
+# any Fibers that pause can be put on it.
+join_queues(pending_fibers,next_fibers)
+ next_fibers.clear
+ end
+ end
+
+ if@pending_jobs.any?
+ raise"Invariant: #{@pending_jobs.size} pending jobs"
+ elsifpending_fibers.any?
+ raise"Invariant: #{pending_fibers.size} pending fibers"
+ elsifnext_fibers.any?
+ raise"Invariant: #{next_fibers.size} next fibers"
+ end
+ nil
+end
+
+
+
+
+
+
+
+
+ #run_isolated ⇒ Object
+
+
+
+
+
+
+
+
Use a self-contained queue for the work in the block.
# File 'lib/graphql/dataloader.rb', line 143
+
+defrun_isolated
+ prev_queue=@pending_jobs
+ prev_pending_keys={}
+ @source_cache.eachdo|source_class,batched_sources|
+ batched_sources.eachdo|batch_args,batched_source_instance|
+ ifbatched_source_instance.pending?
+ prev_pending_keys[batched_source_instance]=batched_source_instance.pending.dup
+ batched_source_instance.pending.clear
+ end
+ end
+ end
+
+ @pending_jobs=[]
+ res=nil
+ # Make sure the block is inside a Fiber, so it can `Fiber.yield`
+append_job{
+ res=yield
+ }
+ run
+ res
+ensure
+ @pending_jobs=prev_queue
+ prev_pending_keys.eachdo|source_instance,pending|
+ source_instance.pending.merge!(pending)
+ end
+end
+
+
+
+
+
+
+
+
+ #set_fiber_variables(vars) ⇒ void
+
+
+
+
+
+
+
+
This method returns an undefined value.
Set up the fiber variables in a new fiber.
+
+
This is called within the fiber, right after it is spawned.
# File 'lib/graphql/dataloader/null_dataloader.rb', line 14
+
+defyield
+ raiseGraphQL::Error,"GraphQL::Dataloader is not running -- add `use GraphQL::Dataloader` to your schema to use Dataloader sources."
+end
+
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/api-doc/2.1.6/GraphQL/Dataloader/Request.html b/api-doc/2.1.6/GraphQL/Dataloader/Request.html
new file mode 100644
index 0000000000..afce93910f
--- /dev/null
+++ b/api-doc/2.1.6/GraphQL/Dataloader/Request.html
@@ -0,0 +1,310 @@
+
+
+
+
+
+
+ Class: GraphQL::Dataloader::Request
+
+ — GraphQL Ruby API Documentation
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
These arguments are given to dataloader.with(source_class, ...). The object
+returned from this method is used to de-duplicate batch loads under the hood
+by using it as a Hash key.
+
+
By default, the arguments are all put in an Array. To customize how this source’s
+batches are merged, override this method to return something else.
+
+
For example, if you pass ActiveRecord::Relations to .with(...), you could override
+this method to call .to_sql on them, thus merging .load(...) calls when they apply
+to equivalent relations.
+
+
+
+
+
+
Parameters:
+
+
+
+
+ batch_args
+
+
+ (Array<Object>)
+
+
+
+
+
+
+
+ batch_kwargs
+
+
+ (Hash)
+
+
+
+
+
+
+
+
Returns:
+
+
+
+
+
+ (Object)
+
+
+
+
+
+
+
+
+
+
+
+
+
+160
+161
+162
+
+
+
# File 'lib/graphql/dataloader/source.rb', line 160
+
+defself.batch_key_for(*batch_args,**batch_kwargs)
+ [*batch_args,**batch_kwargs]
+end
A loaded value for each of keys. The array must match one-for-one to the list of keys.
+
+
+
+
+
+
+
+
+
+
+
+
+86
+87
+88
+89
+
+
+
# File 'lib/graphql/dataloader/source.rb', line 86
+
+deffetch(keys)
+ # somehow retrieve these from the backend
+raise"Implement `#{self.class}#fetch(#{keys.inspect}) to return a record for each of the keys"
+end
+
+
+
+
+
+
+
+
+ #load(value) ⇒ Object
+
+
+
+
+
+
+
+
Returns The result from #fetch for key. If key hasn’t been loaded yet, the Fiber will yield until it’s loaded.
+
+
+
+
+
+
Parameters:
+
+
+
+
+ value
+
+
+ (Object)
+
+
+
+ —
+
A loading value which will be passed to #fetch if it isn’t already in the internal cache.
+
+
+
+
+
+
+
Returns:
+
+
+
+
+
+ (Object)
+
+
+
+ —
+
The result from #fetch for key. If key hasn’t been loaded yet, the Fiber will yield until it’s loaded.
# File 'lib/graphql/dataloader/source.rb', line 8
+
+defsetup(dataloader)
+ # These keys have been requested but haven't been fetched yet
+@pending={}
+ # These keys have been passed to `fetch` but haven't been finished yet
+@fetching={}
+ # { key => result }
+@results={}
+ @dataloader=dataloader
+end
+
+
+
+
+
+
+
+
+ #sync(pending_result_keys) ⇒ void
+
+
+
+
+
+
+
+
This method returns an undefined value.
Wait for a batch, if there’s anything to batch.
+Then run the batch and update the cache.
# File 'lib/graphql/dataloader/source.rb', line 94
+
+defsync(pending_result_keys)
+ @dataloader.yield
+ iterations=0
+ whilepending_result_keys.any?{|key|!@results.key?(key)}
+ iterations+=1
+ ifiterations>1000
+ raise"#{self.class}#sync tried 1000 times to load pending keys (#{pending_result_keys}), but they still weren't loaded. There is likely a circular dependency."
+ end
+ @dataloader.yield
+ end
+ nil
+end
+
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/api-doc/2.1.6/GraphQL/DateEncodingError.html b/api-doc/2.1.6/GraphQL/DateEncodingError.html
new file mode 100644
index 0000000000..6bba5a0b70
--- /dev/null
+++ b/api-doc/2.1.6/GraphQL/DateEncodingError.html
@@ -0,0 +1,320 @@
+
+
+
+
+
+
+ Exception: GraphQL::DateEncodingError
+
+ — GraphQL Ruby API Documentation
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
# File 'lib/graphql/date_encoding_error.rb', line 11
+
+definitialize(value)
+ @date_value=value
+ super("Date cannot be parsed: #{value}. \nDate must be be able to be parsed as a Ruby Date object.")
+end
+
+
+
+
+
+
+
+
+
Instance Attribute Details
+
+
+
+
+
+
+ #date_value ⇒ Object(readonly)
+
+
+
+
+
+
+
+
The value which couldn’t be encoded
+
+
+
+
+
+
+
+
+
+
+
+
+
+9
+10
+11
+
+
+
# File 'lib/graphql/date_encoding_error.rb', line 9
+
+defdate_value
+ @date_value
+end
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/api-doc/2.1.6/GraphQL/Deprecation.html b/api-doc/2.1.6/GraphQL/Deprecation.html
new file mode 100644
index 0000000000..86e40cd0f0
--- /dev/null
+++ b/api-doc/2.1.6/GraphQL/Deprecation.html
@@ -0,0 +1,175 @@
+
+
+
+
+
+
+ Module: GraphQL::Deprecation
+
+ — GraphQL Ruby API Documentation
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
implemented using the old activesupport #dig instead of the ruby built-in so we can use some of the magic in Schema::InputObject and Interpreter::Arguments to handle stringified/symbolized keys.
implemented using the old activesupport #dig instead of the ruby built-in
+so we can use some of the magic in Schema::InputObject and Interpreter::Arguments
+to handle stringified/symbolized keys.
+
+
+
+
+
+
Parameters:
+
+
+
+
+ args
+
+
+ (Array<[String, Symbol>] Retrieves the value object corresponding to the each key objects repeatedly)
+
+
+
+ —
+
rgs [Array<[String, Symbol>] Retrieves the value object corresponding to the each key objects repeatedly
+
+
+
+
+
+
+
Returns:
+
+
+
+
+
+ (Object)
+
+
+
+
+
+
+
+
+
+
+
+
+
+10
+11
+12
+13
+14
+15
+16
+17
+
+
+
# File 'lib/graphql/dig.rb', line 10
+
+defdig(own_key,*rest_keys)
+ val=self[own_key]
+ ifval.nil?||rest_keys.empty?
+ val
+ else
+ val.dig(*rest_keys)
+ end
+end
+
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/api-doc/2.1.6/GraphQL/DurationEncodingError.html b/api-doc/2.1.6/GraphQL/DurationEncodingError.html
new file mode 100644
index 0000000000..c417fdf3c9
--- /dev/null
+++ b/api-doc/2.1.6/GraphQL/DurationEncodingError.html
@@ -0,0 +1,320 @@
+
+
+
+
+
+
+ Exception: GraphQL::DurationEncodingError
+
+ — GraphQL Ruby API Documentation
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
This error is raised when Types::ISO8601Duration is asked to return a value
+that cannot be parsed as an ISO8601-formatted duration by ActiveSupport::Duration.
# File 'lib/graphql/duration_encoding_error.rb', line 11
+
+definitialize(value)
+ @duration_value=value
+ super("Duration cannot be parsed: #{value}. \nDuration must be an ISO8601-formatted duration.")
+end
# File 'lib/graphql/execution/errors.rb', line 56
+
+defself.find_handler_for(schema,error_class)
+ handlers=schema.error_handlers[:subclass_handlers]
+ handler=nil
+ while(handlers)do
+ _err_class,next_handler=handlers.find{|err_class,handler|error_class<=err_class}
+ ifnext_handler
+ handlers=next_handler[:subclass_handlers]
+ handler=next_handler
+ else
+ # Don't reassign `handler` --
+# let the previous assignment carry over outside this block.
+break
+ end
+ end
+
+ # check for a handler from a parent class:
+ifschema.superclass.respond_to?(:error_handlers)
+ parent_handler=find_handler_for(schema.superclass,error_class)
+ end
+
+ # If the inherited handler is more specific than the one defined here,
+# use it.
+# If it's a tie (or there is no parent handler), use the one defined here.
+# If there's an inherited one, but not one defined here, use the inherited one.
+# Otherwise, there's no handler for this error, return `nil`.
+ifparent_handler&&handler&&parent_handler[:class]<handler[:class]
+ parent_handler
+ elsifhandler
+ handler
+ elsifparent_handler
+ parent_handler
+ else
+ nil
+ end
+end
# File 'lib/graphql/execution/errors.rb', line 13
+
+defself.register_rescue_from(error_class,error_handlers,error_handler)
+ subclasses_handlers={}
+ this_level_subclasses=[]
+ # During this traversal, do two things:
+# - Identify any already-registered subclasses of this error class
+# and gather them up to be inserted _under_ this class
+# - Find the point in the index where this handler should be inserted
+# (That is, _under_ any superclasses, or at top-level, if there are no superclasses registered)
+while(error_handlers)do
+ this_level_subclasses.clear
+ # First, identify already-loaded handlers that belong
+# _under_ this one. (That is, they're handlers
+# for subclasses of `error_class`.)
+error_handlers.eachdo|err_class,handler|
+ iferr_class<error_class
+ subclasses_handlers[err_class]=handler
+ this_level_subclasses<<err_class
+ end
+ end
+ # Any handlers that we'll be moving, delete them from this point in the index
+this_level_subclasses.eachdo|err_class|
+ error_handlers.delete(err_class)
+ end
+
+ # See if any keys in this hash are superclasses of this new class:
+next_index_point=error_handlers.find{|err_class,handler|error_class<err_class}
+ ifnext_index_point
+ error_handlers=next_index_point[1][:subclass_handlers]
+ else
+ # this new handler doesn't belong to any sub-handlers,
+# so insert it in the current set of `handlers`
+break
+ end
+ end
+ # Having found the point at which to insert this handler,
+# register it and merge any subclass handlers back in at this point.
+this_class_handlers=error_handlers[error_class]
+ this_class_handlers[:handler]=error_handler
+ this_class_handlers[:subclass_handlers].merge!(subclasses_handlers)
+ nil
+end
+
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/api-doc/2.1.6/GraphQL/Execution/Interpreter.html b/api-doc/2.1.6/GraphQL/Execution/Interpreter.html
new file mode 100644
index 0000000000..b6bd4d2db2
--- /dev/null
+++ b/api-doc/2.1.6/GraphQL/Execution/Interpreter.html
@@ -0,0 +1,564 @@
+
+
+
+
+
+
+ Class: GraphQL::Execution::Interpreter
+
+ — GraphQL Ruby API Documentation
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
# File 'lib/graphql/execution/interpreter.rb', line 24
+
+defrun_all(schema,query_options,context:{},max_complexity:schema.max_complexity)
+ queries=query_options.mapdo|opts|
+ caseopts
+ whenHash
+ GraphQL::Query.new(schema,nil,**opts)
+ whenGraphQL::Query
+ opts
+ else
+ raise"Expected Hash or GraphQL::Query, not #{opts.class} (#{opts.inspect})"
+ end
+ end
+
+ multiplex=Execution::Multiplex.new(schema:schema,queries:queries,context:context,max_complexity:max_complexity)
+ multiplex.current_trace.execute_multiplex(multiplex:multiplex)do
+ schema=multiplex.schema
+ queries=multiplex.queries
+ query_instrumenters=schema.instrumenters[:query]
+ multiplex_instrumenters=schema.instrumenters[:multiplex]
+ lazies_at_depth=Hash.new{|h,k|h[k]=[]}
+
+ # First, run multiplex instrumentation, then query instrumentation for each query
+call_hooks(multiplex_instrumenters,multiplex,:before_multiplex,:after_multiplex)do
+ each_query_call_hooks(query_instrumenters,queries)do
+ schema=multiplex.schema
+ multiplex_analyzers=schema.multiplex_analyzers
+ queries=multiplex.queries
+ ifmultiplex.max_complexity
+ multiplex_analyzers+=[GraphQL::Analysis::AST::MaxQueryComplexity]
+ end
+
+ schema.analysis_engine.analyze_multiplex(multiplex,multiplex_analyzers)
+ begin
+ # Since this is basically the batching context,
+# share it for a whole multiplex
+multiplex.context[:interpreter_instance]||=multiplex.schema.query_execution_strategy.new
+ # Do as much eager evaluation of the query as possible
+results=[]
+ queries.each_with_indexdo|query,idx|
+ multiplex.dataloader.append_job{
+ operation=query.selected_operation
+ result=ifoperation.nil?||!query.valid?||query.context.errors.any?
+ NO_OPERATION
+ else
+ begin
+ # Although queries in a multiplex _share_ an Interpreter instance,
+# they also have another item of state, which is private to that query
+# in particular, assign it here:
+runtime=Runtime.new(query:query,lazies_at_depth:lazies_at_depth)
+ query.context.namespace(:interpreter_runtime)[:runtime]=runtime
+
+ query.current_trace.execute_query(query:query)do
+ runtime.run_eager
+ end
+ rescueGraphQL::ExecutionError=>err
+ query.context.errors<<err
+ NO_OPERATION
+ end
+ end
+ results[idx]=result
+ }
+ end
+
+ multiplex.dataloader.run
+
+ # Then, work through lazy results in a breadth-first way
+multiplex.dataloader.append_job{
+ query=multiplex.queries.length==1?multiplex.queries[0]:nil
+ queries=multiplex?multiplex.queries:[query]
+ final_values=queries.mapdo|query|
+ runtime=query.context.namespace(:interpreter_runtime)[:runtime]
+ # it might not be present if the query has an error
+runtime?runtime.final_result:nil
+ end
+ final_values.compact!
+ multiplex.current_trace.execute_query_lazy(multiplex:multiplex,query:query)do
+ Interpreter::Resolve.resolve_each_depth(lazies_at_depth,multiplex.dataloader)
+ end
+ }
+ multiplex.dataloader.run
+
+ # Then, find all errors and assign the result to the query object
+results.each_with_indexdo|data_result,idx|
+ query=queries[idx]
+ # Assign the result so that it can be accessed in instrumentation
+query.result_values=ifdata_result.equal?(NO_OPERATION)
+ if!query.valid?||query.context.errors.any?
+ # A bit weird, but `Query#static_errors` _includes_ `query.context.errors`
+{"errors"=>query.static_errors.map(&:to_h)}
+ else
+ data_result
+ end
+ else
+ result={
+ "data"=>query.context.namespace(:interpreter_runtime)[:runtime].final_result
+ }
+
+ ifquery.context.errors.any?
+ error_result=query.context.errors.map(&:to_h)
+ result["errors"]=error_result
+ end
+
+ result
+ end
+ ifquery.context.namespace?(:__query_result_extensions__)
+ query.result_values["extensions"]=query.context.namespace(:__query_result_extensions__)
+ end
+ # Get the Query::Result, not the Hash
+results[idx]=query.result
+ end
+
+ results
+ rescueException
+ # TODO rescue at a higher level so it will catch errors in analysis, too
+# Assign values here so that the query's `@executed` becomes true
+queries.map{|q|q.result_values||={}}
+ raise
+ ensure
+ queries.map{|query|
+ runtime=query.context.namespace(:interpreter_runtime)[:runtime]
+ ifruntime
+ runtime.delete_all_interpreter_context
+ end
+ }
+ end
+ end
+ end
+ end
+end
+
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/api-doc/2.1.6/GraphQL/Execution/Interpreter/ArgumentValue.html b/api-doc/2.1.6/GraphQL/Execution/Interpreter/ArgumentValue.html
new file mode 100644
index 0000000000..b66c23d648
--- /dev/null
+++ b/api-doc/2.1.6/GraphQL/Execution/Interpreter/ArgumentValue.html
@@ -0,0 +1,492 @@
+
+
+
+
+
+
+ Class: GraphQL::Execution::Interpreter::ArgumentValue
+
+ — GraphQL Ruby API Documentation
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
# File 'lib/graphql/execution/interpreter/arguments.rb', line 24
+
+definitialize(keyword_arguments:nil,argument_values:)
+ @empty=argument_values.nil?||argument_values.empty?
+ # This is only present when `extras` have been merged in:
+ifkeyword_arguments
+ # This is a little crazy. We expect the `:argument_details` extra to _include extras_,
+# but the object isn't created until _after_ extras are put together.
+# So, we have to use a special flag here to say, "at the last minute, add yourself to the keyword args."
+#
+# Otherwise:
+# - We can't access the final Arguments instance _while_ we're preparing extras
+# - After we _can_ access it, it's frozen, so we can't add anything.
+#
+# So, this flag gives us a chance to sneak it in before freezing, _and_ while we have access
+# to the new Arguments instance itself.
+ifkeyword_arguments[:argument_details]==:__arguments_add_self
+ keyword_arguments[:argument_details]=self
+ end
+ @keyword_arguments=keyword_arguments.freeze
+ elsif!@empty
+ @keyword_arguments={}
+ argument_values.eachdo|name,arg_val|
+ @keyword_arguments[name]=arg_val.value
+ end
+ @keyword_arguments.freeze
+ else
+ @keyword_arguments=NO_ARGS
+ end
+ @argument_values=argument_values?argument_values.freeze:NO_ARGS
+ freeze
+end
# File 'lib/graphql/execution/interpreter/arguments_cache.rb', line 29
+
+deffetch(ast_node,argument_owner,parent_object)
+ # This runs eagerly if no block is given
+@storage[argument_owner][parent_object][ast_node]||=begin
+ args_hash=self.class.prepare_args_hash(@query,ast_node)
+ kwarg_arguments=argument_owner.coerce_arguments(parent_object,args_hash,@query.context)
+ @query.after_lazy(kwarg_arguments)do|resolved_args|
+ @storage[argument_owner][parent_object][ast_node]=resolved_args
+ end
+ end
+
+end
+
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/api-doc/2.1.6/GraphQL/Execution/Interpreter/ExecutionErrors.html b/api-doc/2.1.6/GraphQL/Execution/Interpreter/ExecutionErrors.html
new file mode 100644
index 0000000000..c81650b8dc
--- /dev/null
+++ b/api-doc/2.1.6/GraphQL/Execution/Interpreter/ExecutionErrors.html
@@ -0,0 +1,284 @@
+
+
+
+
+
+
+ Class: GraphQL::Execution::Interpreter::ExecutionErrors
+
+ — GraphQL Ruby API Documentation
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
# File 'lib/graphql/execution/interpreter.rb', line 211
+
+definitialize(value:,path:,field:)
+ message="Failed to build a GraphQL list result for field `#{field.path}` at path `#{path.join(".")}`.\n".dup
+
+ message<<"Expected `#{value.inspect}` (#{value.class}) to implement `.each` to satisfy the GraphQL return type `#{field.type.to_type_signature}`.\n"
+
+ iffield.connection?
+ message<<"\nThis field was treated as a Relay-style connection; add `connection: false` to the `field(...)` to disable this behavior."
+ end
+ super(message)
+end
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/api-doc/2.1.6/GraphQL/Execution/Interpreter/RawValue.html b/api-doc/2.1.6/GraphQL/Execution/Interpreter/RawValue.html
new file mode 100644
index 0000000000..cee69ecca6
--- /dev/null
+++ b/api-doc/2.1.6/GraphQL/Execution/Interpreter/RawValue.html
@@ -0,0 +1,270 @@
+
+
+
+
+
+
+ Class: GraphQL::Execution::Interpreter::RawValue
+
+ — GraphQL Ruby API Documentation
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
# File 'lib/graphql/execution/interpreter/resolve.rb', line 46
+
+defself.resolve(results,dataloader)
+ # There might be pending jobs here that _will_ write lazies
+# into the result hash. We should run them out, so we
+# can be sure that all lazies will be present in the result hashes.
+# A better implementation would somehow interleave (or unify)
+# these approaches.
+dataloader.run
+ next_results=[]
+ whileresults.any?
+ result_value=results.shift
+ ifresult_value.is_a?(Runtime::GraphQLResultHash)||result_value.is_a?(Hash)
+ results.concat(result_value.values)
+ next
+ elsifresult_value.is_a?(Runtime::GraphQLResultArray)
+ results.concat(result_value.values)
+ next
+ elsifresult_value.is_a?(Array)
+ results.concat(result_value)
+ next
+ elsifresult_value.is_a?(Lazy)
+ loaded_value=result_value.value
+ ifloaded_value.is_a?(Lazy)
+ # Since this field returned another lazy,
+# add it to the same queue
+results<<loaded_value
+ elsifloaded_value.is_a?(Runtime::GraphQLResultHash)||loaded_value.is_a?(Runtime::GraphQLResultArray)||
+ loaded_value.is_a?(Hash)||loaded_value.is_a?(Array)
+ # Add these values in wholesale --
+# they might be modified by later work in the dataloader.
+next_results<<loaded_value
+ end
+ end
+ end
+
+ ifnext_results.any?
+ # Any pending data loader jobs may populate the
+# resutl arrays or result hashes accumulated in
+# `next_results``. Run those **to completion**
+# before continuing to resolve `next_results`.
+# (Just `.append_job` doesn't work if any pending
+# jobs require multiple passes.)
+dataloader.run
+ dataloader.append_job{resolve(next_results,dataloader)}
+ end
+
+ nil
+end
# File 'lib/graphql/execution/interpreter/runtime.rb', line 779
+
+defafter_lazy(lazy_obj,field:,owner_object:,arguments:,ast_node:,result:,result_name:,eager:false,runtime_state:,trace:true,&block)
+ iflazy?(lazy_obj)
+ orig_result=result
+ was_authorized_by_scope_items=runtime_state.was_authorized_by_scope_items
+ lazy=GraphQL::Execution::Lazy.new(field:field)do
+ # This block might be called in a new fiber;
+# In that case, this will initialize a new state
+# to avoid conflicting with the parent fiber.
+runtime_state=get_current_runtime_state
+ runtime_state.current_object=owner_object
+ runtime_state.current_field=field
+ runtime_state.current_arguments=arguments
+ runtime_state.current_result_name=result_name
+ runtime_state.current_result=orig_result
+ runtime_state.was_authorized_by_scope_items=was_authorized_by_scope_items
+ # Wrap the execution of _this_ method with tracing,
+# but don't wrap the continuation below
+inner_obj=begin
+ iftrace
+ @current_trace.execute_field_lazy(field:field,query:query,object:owner_object,arguments:arguments,ast_node:ast_node)do
+ schema.sync_lazy(lazy_obj)
+ end
+ else
+ schema.sync_lazy(lazy_obj)
+ end
+ rescueGraphQL::ExecutionError,GraphQL::UnauthorizedError=>ex_err
+ ex_err
+ rescueStandardError=>err
+ begin
+ query.handle_or_reraise(err)
+ rescueGraphQL::ExecutionError=>ex_err
+ ex_err
+ end
+ end
+ yield(inner_obj,runtime_state)
+ end
+
+ ifeager
+ lazy.value
+ else
+ set_result(result,result_name,lazy,false,false)# is_non_null is irrelevant here
+current_depth=0
+ whileresult
+ current_depth+=1
+ result=result.graphql_parent
+ end
+ @lazies_at_depth[current_depth]<<lazy
+ lazy
+ end
+ else
+ # Don't need to reset state here because it _wasn't_ lazy.
+yield(lazy_obj,runtime_state)
+ end
+end
+ This method is part of a private API.
+ You should avoid using this method if possible, as it may be removed or be changed in the future.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+834
+835
+836
+837
+838
+839
+840
+841
+
+
+
# File 'lib/graphql/execution/interpreter/runtime.rb', line 834
+
+defarguments(graphql_object,arg_owner,ast_node)
+ ifarg_owner.arguments_statically_coercible?
+ query.arguments_for(ast_node,arg_owner)
+ else
+ # The arguments must be prepared in the context of the given object
+query.arguments_for(ast_node,arg_owner,parent_object:graphql_object)
+ end
+end
# File 'lib/graphql/execution/interpreter/runtime.rb', line 554
+
+defcontinue_field(value,owner_type,field,current_type,ast_node,next_selections,is_non_null,owner_object,arguments,result_name,selection_result,was_scoped,runtime_state)# rubocop:disable Metrics/ParameterLists
+ifcurrent_type.non_null?
+ current_type=current_type.of_type
+ is_non_null=true
+ end
+
+ casecurrent_type.kind.name
+ when"SCALAR","ENUM"
+ r=begin
+ current_type.coerce_result(value,context)
+ rescueStandardError=>err
+ schema.handle_or_reraise(context,err)
+ end
+ set_result(selection_result,result_name,r,false,is_non_null)
+ r
+ when"UNION","INTERFACE"
+ resolved_type_or_lazy=resolve_type(current_type,value)
+ after_lazy(resolved_type_or_lazy,ast_node:ast_node,field:field,owner_object:owner_object,arguments:arguments,trace:false,result_name:result_name,result:selection_result,runtime_state:runtime_state)do|resolved_type_result,runtime_state|
+ ifresolved_type_result.is_a?(Array)&&resolved_type_result.length==2
+ resolved_type,resolved_value=resolved_type_result
+ else
+ resolved_type=resolved_type_result
+ resolved_value=value
+ end
+
+ possible_types=query.possible_types(current_type)
+ if!possible_types.include?(resolved_type)
+ parent_type=field.owner_type
+ err_class=current_type::UnresolvedTypeError
+ type_error=err_class.new(resolved_value,field,parent_type,resolved_type,possible_types)
+ schema.type_error(type_error,context)
+ set_result(selection_result,result_name,nil,false,is_non_null)
+ nil
+ else
+ continue_field(resolved_value,owner_type,field,resolved_type,ast_node,next_selections,is_non_null,owner_object,arguments,result_name,selection_result,was_scoped,runtime_state)
+ end
+ end
+ when"OBJECT"
+ object_proxy=begin
+ was_scoped?current_type.wrap_scoped(value,context):current_type.wrap(value,context)
+ rescueGraphQL::ExecutionError=>err
+ err
+ end
+ after_lazy(object_proxy,ast_node:ast_node,field:field,owner_object:owner_object,arguments:arguments,trace:false,result_name:result_name,result:selection_result,runtime_state:runtime_state)do|inner_object,runtime_state|
+ continue_value=continue_value(inner_object,owner_type,field,is_non_null,ast_node,result_name,selection_result)
+ ifHALT!=continue_value
+ response_hash=GraphQLResultHash.new(result_name,selection_result,is_non_null)
+ set_result(selection_result,result_name,response_hash,true,is_non_null)
+
+ gathered_selections=gather_selections(continue_value,current_type,next_selections)
+ # There are two possibilities for `gathered_selections`:
+# 1. All selections of this object should be evaluated together (there are no runtime directives modifying execution).
+# This case is handled below, and the result can be written right into the main `response_hash` above.
+# In this case, `gathered_selections` is a hash of selections.
+# 2. Some selections of this object have runtime directives that may or may not modify execution.
+# That part of the selection is evaluated in an isolated way, writing into a sub-response object which is
+# eventually merged into the final response. In this case, `gathered_selections` is an array of things to run in isolation.
+# (Technically, it's possible that one of those entries _doesn't_ require isolation.)
+tap_or_each(gathered_selections)do|selections,is_selection_array|
+ ifis_selection_array
+ this_result=GraphQLResultHash.new(result_name,selection_result,is_non_null)
+ final_result=response_hash
+ else
+ this_result=response_hash
+ final_result=nil
+ end
+ # reset this mutable state
+# Unset `result_name` here because it's already included in the new response hash
+runtime_state.current_object=continue_value
+ runtime_state.current_result_name=nil
+ runtime_state.current_result=this_result
+ # This is a less-frequent case; use a fast check since it's often not there.
+if(directives=selections[:graphql_directives])
+ selections.delete(:graphql_directives)
+ end
+ call_method_on_directives(:resolve,continue_value,directives)do
+ evaluate_selections(
+ continue_value,
+ current_type,
+ false,
+ selections,
+ this_result,
+ final_result,
+ owner_object.object,
+ runtime_state,
+ )
+ this_result
+ end
+ end
+ end
+ end
+ when"LIST"
+ inner_type=current_type.of_type
+ # This is true for objects, unions, and interfaces
+use_dataloader_job=!inner_type.unwrap.kind.input?
+ inner_type_non_null=inner_type.non_null?
+ response_list=GraphQLResultArray.new(result_name,selection_result,is_non_null)
+ set_result(selection_result,result_name,response_list,true,is_non_null)
+ idx=nil
+ list_value=begin
+ value.eachdo|inner_value|
+ idx||=0
+ this_idx=idx
+ idx+=1
+ ifuse_dataloader_job
+ @dataloader.append_jobdo
+ resolve_list_item(inner_value,inner_type,inner_type_non_null,ast_node,field,owner_object,arguments,this_idx,response_list,next_selections,owner_type,was_scoped,runtime_state)
+ end
+ else
+ resolve_list_item(inner_value,inner_type,inner_type_non_null,ast_node,field,owner_object,arguments,this_idx,response_list,next_selections,owner_type,was_scoped,runtime_state)
+ end
+ end
+
+ response_list
+ rescueNoMethodError=>err
+ # Ruby 2.2 doesn't have NoMethodError#receiver, can't check that one in this case. (It's been EOL since 2017.)
+iferr.name==:each&&(err.respond_to?(:receiver)?err.receiver==value:true)
+ # This happens when the GraphQL schema doesn't match the implementation. Help the dev debug.
+raiseListResultFailedError.new(value:value,field:field,path:current_path)
+ else
+ # This was some other NoMethodError -- let it bubble to reveal the real error.
+raise
+ end
+ rescueGraphQL::ExecutionError,GraphQL::UnauthorizedError=>ex_err
+ ex_err
+ rescueStandardError=>err
+ begin
+ query.handle_or_reraise(err)
+ rescueGraphQL::ExecutionError=>ex_err
+ ex_err
+ end
+ end
+ # Detect whether this error came while calling `.each` (before `idx` is set) or while running list *items* (after `idx` is set)
+error_is_non_null=idx.nil??is_non_null:inner_type.non_null?
+ continue_value(list_value,owner_type,field,error_is_non_null,ast_node,result_name,selection_result)
+ else
+ raise"Invariant: Unhandled type kind #{current_type.kind} (#{current_type})"
+ end
+end
# File 'lib/graphql/execution/interpreter/runtime.rb', line 450
+
+defcontinue_value(value,parent_type,field,is_non_null,ast_node,result_name,selection_result)# rubocop:disable Metrics/ParameterLists
+casevalue
+ whennil
+ ifis_non_null
+ set_result(selection_result,result_name,nil,false,is_non_null)do
+ # This block is called if `result_name` is not dead. (Maybe a previous invalid nil caused it be marked dead.)
+err=parent_type::InvalidNullError.new(parent_type,field,value)
+ schema.type_error(err,context)
+ end
+ else
+ set_result(selection_result,result_name,nil,false,is_non_null)
+ end
+ HALT
+ whenGraphQL::Error
+ # Handle these cases inside a single `when`
+# to avoid the overhead of checking three different classes
+# every time.
+ifvalue.is_a?(GraphQL::ExecutionError)
+ ifselection_result.nil?||!dead_result?(selection_result)
+ value.path||=current_path
+ value.ast_node||=ast_node
+ context.errors<<value
+ ifselection_result
+ set_result(selection_result,result_name,nil,false,is_non_null)
+ end
+ end
+ HALT
+ elsifvalue.is_a?(GraphQL::UnauthorizedFieldError)
+ value.field||=field
+ # this hook might raise & crash, or it might return
+# a replacement value
+next_value=begin
+ schema.unauthorized_field(value)
+ rescueGraphQL::ExecutionError=>err
+ err
+ end
+ continue_value(next_value,parent_type,field,is_non_null,ast_node,result_name,selection_result)
+ elsifvalue.is_a?(GraphQL::UnauthorizedError)
+ # this hook might raise & crash, or it might return
+# a replacement value
+next_value=begin
+ schema.unauthorized_object(value)
+ rescueGraphQL::ExecutionError=>err
+ err
+ end
+ continue_value(next_value,parent_type,field,is_non_null,ast_node,result_name,selection_result)
+ elsifGraphQL::Execution::SKIP==value
+ # It's possible a lazy was already written here
+caseselection_result
+ whenGraphQLResultHash
+ selection_result.delete(result_name)
+ whenGraphQLResultArray
+ selection_result.graphql_skip_at(result_name)
+ whennil
+ # this can happen with directives
+else
+ raise"Invariant: unexpected result class #{selection_result.class} (#{selection_result.inspect})"
+ end
+ HALT
+ else
+ # What could this actually _be_? Anyhow,
+# preserve the default behavior of doing nothing with it.
+value
+ end
+ whenArray
+ # It's an array full of execution errors; add them all.
+ifvalue.any?&&value.all?{|v|v.is_a?(GraphQL::ExecutionError)}
+ list_type_at_all=(field&&(field.type.list?))
+ ifselection_result.nil?||!dead_result?(selection_result)
+ value.each_with_indexdo|error,index|
+ error.ast_node||=ast_node
+ error.path||=current_path+(list_type_at_all?[index]:[])
+ context.errors<<error
+ end
+ ifselection_result
+ iflist_type_at_all
+ result_without_errors=value.map{|v|v.is_a?(GraphQL::ExecutionError)?nil:v}
+ set_result(selection_result,result_name,result_without_errors,false,is_non_null)
+ else
+ set_result(selection_result,result_name,nil,false,is_non_null)
+ end
+ end
+ end
+ HALT
+ else
+ value
+ end
+ whenGraphQL::Execution::Interpreter::RawValue
+ # Write raw value directly to the response without resolving nested objects
+set_result(selection_result,result_name,value.resolve,false,is_non_null)
+ HALT
+ else
+ value
+ end
+end
+
+
+
+
+
+
+
+
+ #current_path ⇒ Object
+
+
+
+
+
+
+
+
+ This method is part of a private API.
+ You should avoid using this method if possible, as it may be removed or be changed in the future.
+
# File 'lib/graphql/execution/interpreter/runtime.rb', line 236
+
+defevaluate_selection(result_name,field_ast_nodes_or_ast_node,owner_object,owner_type,is_eager_field,selections_result,parent_object,runtime_state)# rubocop:disable Metrics/ParameterLists
+returnifdead_result?(selections_result)
+ # As a performance optimization, the hash key will be a `Node` if
+# there's only one selection of the field. But if there are multiple
+# selections of the field, it will be an Array of nodes
+iffield_ast_nodes_or_ast_node.is_a?(Array)
+ field_ast_nodes=field_ast_nodes_or_ast_node
+ ast_node=field_ast_nodes.first
+ else
+ field_ast_nodes=nil
+ ast_node=field_ast_nodes_or_ast_node
+ end
+ field_name=ast_node.name
+ field_defn=query.warden.get_field(owner_type,field_name)
+
+ # Set this before calling `run_with_directives`, so that the directive can have the latest path
+runtime_state.current_field=field_defn
+ runtime_state.current_result=selections_result
+ runtime_state.current_result_name=result_name
+
+ iffield_defn.dynamic_introspection
+ owner_object=field_defn.owner.wrap(owner_object,context)
+ end
+
+ return_type=field_defn.type
+ if!field_defn.any_arguments?
+ resolved_arguments=GraphQL::Execution::Interpreter::Arguments::EMPTY
+ iffield_defn.extras.size==0
+ evaluate_selection_with_resolved_keyword_args(
+ NO_ARGS,resolved_arguments,field_defn,ast_node,field_ast_nodes,owner_type,owner_object,is_eager_field,result_name,selections_result,parent_object,return_type,return_type.non_null?,runtime_state
+ )
+ else
+ evaluate_selection_with_args(resolved_arguments,field_defn,ast_node,field_ast_nodes,owner_type,owner_object,is_eager_field,result_name,selections_result,parent_object,return_type,runtime_state)
+ end
+ else
+ @query.arguments_cache.dataload_for(ast_node,field_defn,owner_object)do|resolved_arguments|
+ runtime_state=get_current_runtime_state# This might be in a different fiber
+evaluate_selection_with_args(resolved_arguments,field_defn,ast_node,field_ast_nodes,owner_type,owner_object,is_eager_field,result_name,selections_result,parent_object,return_type,runtime_state)
+ end
+ end
+end
# File 'lib/graphql/execution/interpreter/runtime.rb', line 278
+
+defevaluate_selection_with_args(arguments,field_defn,ast_node,field_ast_nodes,owner_type,object,is_eager_field,result_name,selection_result,parent_object,return_type,runtime_state)# rubocop:disable Metrics/ParameterLists
+after_lazy(arguments,field:field_defn,ast_node:ast_node,owner_object:object,arguments:arguments,result_name:result_name,result:selection_result,runtime_state:runtime_state)do|resolved_arguments,runtime_state|
+ return_type_non_null=return_type.non_null?
+ ifresolved_arguments.is_a?(GraphQL::ExecutionError)||resolved_arguments.is_a?(GraphQL::UnauthorizedError)
+ continue_value(resolved_arguments,owner_type,field_defn,return_type_non_null,ast_node,result_name,selection_result)
+ next
+ end
+
+ kwarg_arguments=iffield_defn.extras.empty?
+ ifresolved_arguments.empty?
+ # We can avoid allocating the `{ Symbol => Object }` hash in this case
+NO_ARGS
+ else
+ resolved_arguments.keyword_arguments
+ end
+ else
+ # Bundle up the extras, then make a new arguments instance
+# that includes the extras, too.
+extra_args={}
+ field_defn.extras.eachdo|extra|
+ caseextra
+ when:ast_node
+ extra_args[:ast_node]=ast_node
+ when:execution_errors
+ extra_args[:execution_errors]=ExecutionErrors.new(context,ast_node,current_path)
+ when:path
+ extra_args[:path]=current_path
+ when:lookahead
+ if!field_ast_nodes
+ field_ast_nodes=[ast_node]
+ end
+
+ extra_args[:lookahead]=Execution::Lookahead.new(
+ query:query,
+ ast_nodes:field_ast_nodes,
+ field:field_defn,
+ )
+ when:argument_details
+ # Use this flag to tell Interpreter::Arguments to add itself
+# to the keyword args hash _before_ freezing everything.
+extra_args[:argument_details]=:__arguments_add_self
+ when:parent
+ extra_args[:parent]=parent_object
+ else
+ extra_args[extra]=field_defn.fetch_extra(extra,context)
+ end
+ end
+ ifextra_args.any?
+ resolved_arguments=resolved_arguments.merge_extras(extra_args)
+ end
+ resolved_arguments.keyword_arguments
+ end
+
+ evaluate_selection_with_resolved_keyword_args(kwarg_arguments,resolved_arguments,field_defn,ast_node,field_ast_nodes,owner_type,object,is_eager_field,result_name,selection_result,parent_object,return_type,return_type_non_null,runtime_state)
+ end
+end
# File 'lib/graphql/execution/interpreter/runtime.rb', line 335
+
+defevaluate_selection_with_resolved_keyword_args(kwarg_arguments,resolved_arguments,field_defn,ast_node,field_ast_nodes,owner_type,object,is_eager_field,result_name,selection_result,parent_object,return_type,return_type_non_null,runtime_state)# rubocop:disable Metrics/ParameterLists
+runtime_state.current_field=field_defn
+ runtime_state.current_object=object
+ runtime_state.current_arguments=resolved_arguments
+ runtime_state.current_result_name=result_name
+ runtime_state.current_result=selection_result
+ # Optimize for the case that field is selected only once
+iffield_ast_nodes.nil?||field_ast_nodes.size==1
+ next_selections=ast_node.selections
+ directives=ast_node.directives
+ else
+ next_selections=[]
+ directives=[]
+ field_ast_nodes.each{|f|
+ next_selections.concat(f.selections)
+ directives.concat(f.directives)
+ }
+ end
+
+ field_result=call_method_on_directives(:resolve,object,directives)do
+ # Actually call the field resolver and capture the result
+app_result=begin
+ @current_trace.execute_field(field:field_defn,ast_node:ast_node,query:query,object:object,arguments:kwarg_arguments)do
+ field_defn.resolve(object,kwarg_arguments,context)
+ end
+ rescueGraphQL::ExecutionError=>err
+ err
+ rescueStandardError=>err
+ begin
+ query.handle_or_reraise(err)
+ rescueGraphQL::ExecutionError=>ex_err
+ ex_err
+ end
+ end
+ after_lazy(app_result,field:field_defn,ast_node:ast_node,owner_object:object,arguments:resolved_arguments,result_name:result_name,result:selection_result,runtime_state:runtime_state)do|inner_result,runtime_state|
+ continue_value=continue_value(inner_result,owner_type,field_defn,return_type_non_null,ast_node,result_name,selection_result)
+ ifHALT!=continue_value
+ was_scoped=runtime_state.was_authorized_by_scope_items
+ runtime_state.was_authorized_by_scope_items=nil
+ continue_field(continue_value,owner_type,field_defn,return_type,ast_node,next_selections,false,object,resolved_arguments,result_name,selection_result,was_scoped,runtime_state)
+ end
+ end
+ end
+
+ # If this field is a root mutation field, immediately resolve
+# all of its child fields before moving on to the next root mutation field.
+# (Subselections of this mutation will still be resolved level-by-level.)
+ifis_eager_field
+ Interpreter::Resolve.resolve_all([field_result],@dataloader)
+ else
+ # Return this from `after_lazy` because it might be another lazy that needs to be resolved
+field_result
+ end
+end
# File 'lib/graphql/execution/interpreter/runtime.rb', line 208
+
+defevaluate_selections(owner_object,owner_type,is_eager_selection,gathered_selections,selections_result,target_result,parent_object,runtime_state)# rubocop:disable Metrics/ParameterLists
+finished_jobs=0
+ enqueued_jobs=gathered_selections.size
+ gathered_selections.eachdo|result_name,field_ast_nodes_or_ast_node|
+ @dataloader.append_job{
+ runtime_state=get_current_runtime_state
+ evaluate_selection(
+ result_name,field_ast_nodes_or_ast_node,owner_object,owner_type,is_eager_selection,selections_result,parent_object,runtime_state
+ )
+ finished_jobs+=1
+ iftarget_result&&finished_jobs==enqueued_jobs
+ selections_result.merge_into(target_result)
+ end
+ }
+ # Field resolution may pause the fiber,
+# so it wouldn't get to the `Resolve` call that happens below.
+# So instead trigger a run from this outer context.
+ifis_eager_selection
+ @dataloader.clear_cache
+ @dataloader.run
+ @dataloader.clear_cache
+ end
+ end
+
+ selections_result
+end
+
+
+
+
+
+
+
+
+ #final_result ⇒ Object
+
+
+
+
+
+
+
+
+ This method is part of a private API.
+ You should avoid using this method if possible, as it may be removed or be changed in the future.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+57
+58
+59
+
+
+
# File 'lib/graphql/execution/interpreter/runtime.rb', line 57
+
+deffinal_result
+ @response&&@response.graphql_result_data
+end
# File 'lib/graphql/execution/interpreter/runtime.rb', line 139
+
+defgather_selections(owner_object,owner_type,selections,selections_to_run=nil,selections_by_name={})
+
+ selections.eachdo|node|
+ # Skip gathering this if the directive says so
+if!directives_include?(node,owner_object,owner_type)
+ next
+ end
+
+ ifnode.is_a?(GraphQL::Language::Nodes::Field)
+ response_key=node.alias||node.name
+ selections=selections_by_name[response_key]
+ # if there was already a selection of this field,
+# use an array to hold all selections,
+# otherise, use the single node to represent the selection
+ifselections
+ # This field was already selected at least once,
+# add this node to the list of selections
+s=Array(selections)
+ s<<node
+ selections_by_name[response_key]=s
+ else
+ # No selection was found for this field yet
+selections_by_name[response_key]=node
+ end
+ else
+ # This is an InlineFragment or a FragmentSpread
+if@runtime_directive_names.any?&&node.directives.any?{|d|@runtime_directive_names.include?(d.name)}
+ next_selections={}
+ next_selections[:graphql_directives]=node.directives
+ ifselections_to_run
+ selections_to_run<<next_selections
+ else
+ selections_to_run=[]
+ selections_to_run<<selections_by_name
+ selections_to_run<<next_selections
+ end
+ else
+ next_selections=selections_by_name
+ end
+
+ casenode
+ whenGraphQL::Language::Nodes::InlineFragment
+ ifnode.type
+ type_defn=schema.get_type(node.type.name,context)
+
+ ifquery.warden.possible_types(type_defn).include?(owner_type)
+ gather_selections(owner_object,owner_type,node.selections,selections_to_run,next_selections)
+ end
+ else
+ # it's an untyped fragment, definitely continue
+gather_selections(owner_object,owner_type,node.selections,selections_to_run,next_selections)
+ end
+ whenGraphQL::Language::Nodes::FragmentSpread
+ fragment_def=query.fragments[node.name]
+ type_defn=query.get_type(fragment_def.type.name)
+ ifquery.warden.possible_types(type_defn).include?(owner_type)
+ gather_selections(owner_object,owner_type,fragment_def.selections,selections_to_run,next_selections)
+ end
+ else
+ raise"Invariant: unexpected selection class: #{node.class}"
+ end
+ end
+ end
+ selections_to_run||selections_by_name
+end
# File 'lib/graphql/execution/interpreter/runtime.rb', line 762
+
+defminimal_after_lazy(value,&block)
+ iflazy?(value)
+ GraphQL::Execution::Lazy.newdo
+ result=@schema.sync_lazy(value)
+ # The returned result might also be lazy, so check it, too
+minimal_after_lazy(result,&block)
+ end
+ else
+ yield(value)
+ end
+end
# File 'lib/graphql/execution/interpreter/runtime.rb', line 694
+
+defresolve_list_item(inner_value,inner_type,inner_type_non_null,ast_node,field,owner_object,arguments,this_idx,response_list,next_selections,owner_type,was_scoped,runtime_state)# rubocop:disable Metrics/ParameterLists
+runtime_state.current_result_name=this_idx
+ runtime_state.current_result=response_list
+ call_method_on_directives(:resolve_each,owner_object,ast_node.directives)do
+ # This will update `response_list` with the lazy
+after_lazy(inner_value,ast_node:ast_node,field:field,owner_object:owner_object,arguments:arguments,result_name:this_idx,result:response_list,runtime_state:runtime_state)do|inner_inner_value,runtime_state|
+ continue_value=continue_value(inner_inner_value,owner_type,field,inner_type_non_null,ast_node,this_idx,response_list)
+ ifHALT!=continue_value
+ continue_field(continue_value,owner_type,field,inner_type,ast_node,next_selections,false,owner_object,arguments,this_idx,response_list,was_scoped,runtime_state)
+ end
+ end
+ end
+end
# File 'lib/graphql/execution/interpreter/runtime.rb', line 78
+
+defrun_eager
+ root_operation=query.selected_operation
+ root_op_type=root_operation.operation_type||"query"
+ root_type=schema.root_type_for_operation(root_op_type)
+
+ st=get_current_runtime_state
+ st.current_object=query.root_value
+ st.current_result=@response
+ runtime_object=root_type.wrap(query.root_value,context)
+ runtime_object=schema.sync_lazy(runtime_object)
+
+ ifruntime_object.nil?
+ # Root .authorized? returned false.
+@response=nil
+ else
+ call_method_on_directives(:resolve,runtime_object,root_operation.directives)do# execute query level directives
+gathered_selections=gather_selections(runtime_object,root_type,root_operation.selections)
+ # This is kind of a hack -- `gathered_selections` is an Array if any of the selections
+# require isolation during execution (because of runtime directives). In that case,
+# make a new, isolated result hash for writing the result into. (That isolated response
+# is eventually merged back into the main response)
+#
+# Otherwise, `gathered_selections` is a hash of selections which can be
+# directly evaluated and the results can be written right into the main response hash.
+tap_or_each(gathered_selections)do|selections,is_selection_array|
+ ifis_selection_array
+ selection_response=GraphQLResultHash.new(nil,nil,false)
+ final_response=@response
+ else
+ selection_response=@response
+ final_response=nil
+ end
+
+ @dataloader.append_job{
+ st=get_current_runtime_state
+ st.current_object=query.root_value
+ st.current_result_name=nil
+ st.current_result=selection_response
+ # This is a less-frequent case; use a fast check since it's often not there.
+if(directives=selections[:graphql_directives])
+ selections.delete(:graphql_directives)
+ end
+ call_method_on_directives(:resolve,runtime_object,directives)do
+ evaluate_selections(
+ runtime_object,
+ root_type,
+ root_op_type=="mutation",
+ selections,
+ selection_response,
+ final_response,
+ nil,
+ st,
+ )
+ end
+ }
+ end
+ end
+ end
+ nil
+end
# File 'lib/graphql/execution/interpreter/runtime.rb', line 395
+
+defset_result(selection_result,result_name,value,is_child_result,is_non_null)
+ if!dead_result?(selection_result)
+ ifvalue.nil?&&is_non_null
+ # This is an invalid nil that should be propagated
+# One caller of this method passes a block,
+# namely when application code returns a `nil` to GraphQL and it doesn't belong there.
+# The other possibility for reaching here is when a field returns an ExecutionError, so we write
+# `nil` to the response, not knowing whether it's an invalid `nil` or not.
+# (And in that case, we don't have to call the schema's handler, since it's not a bug in the application.)
+# TODO the code is trying to tell me something.
+yieldifblock_given?
+ parent=selection_result.graphql_parent
+ ifparent.nil?# This is a top-level result hash
+@response=nil
+ else
+ name_in_parent=selection_result.graphql_result_name
+ is_non_null_in_parent=selection_result.graphql_is_non_null_in_parent
+ set_result(parent,name_in_parent,nil,false,is_non_null_in_parent)
+ set_graphql_dead(selection_result)
+ end
+ elsifis_child_result
+ selection_result.set_child_result(result_name,value)
+ else
+ selection_result.set_leaf(result_name,value)
+ end
+ end
+end
+ This method is part of a private API.
+ You should avoid using this method if possible, as it may be removed or be changed in the future.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+8
+9
+10
+11
+12
+13
+14
+15
+16
+17
+
+
+
# File 'lib/graphql/execution/interpreter/runtime/graphql_result.rb', line 8
+
+definitialize(result_name,parent_result,is_non_null_in_parent)
+ @graphql_parent=parent_result
+ ifparent_result&&parent_result.graphql_dead
+ @graphql_dead=true
+ end
+ @graphql_result_name=result_name
+ @graphql_is_non_null_in_parent=is_non_null_in_parent
+ # Jump through some hoops to avoid creating this duplicate storage if at all possible.
+@graphql_metadata=nil
+end
+
+
+
+
+
+
+
+
+ #path ⇒ Object
+
+
+
+
+
+
+
+
+ This method is part of a private API.
+ You should avoid using this method if possible, as it may be removed or be changed in the future.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+19
+20
+21
+
+
+
# File 'lib/graphql/execution/interpreter/runtime/graphql_result.rb', line 19
+
+defpath
+ @path||=build_path([])
+end
+
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/api-doc/2.1.6/GraphQL/Execution/Interpreter/Runtime/GraphQLResultArray.html b/api-doc/2.1.6/GraphQL/Execution/Interpreter/Runtime/GraphQLResultArray.html
new file mode 100644
index 0000000000..a423578371
--- /dev/null
+++ b/api-doc/2.1.6/GraphQL/Execution/Interpreter/Runtime/GraphQLResultArray.html
@@ -0,0 +1,560 @@
+
+
+
+
+
+
+ Class: GraphQL::Execution::Interpreter::Runtime::GraphQLResultArray
+
+ — GraphQL Ruby API Documentation
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
# File 'lib/graphql/execution/interpreter/runtime/graphql_result.rb', line 129
+
+defgraphql_skip_at(index)
+ # Mark this index as dead. It's tricky because some indices may already be storing
+# `Lazy`s. So the runtime is still holding indexes _before_ skipping,
+# this object has to coordinate incoming writes to account for any already-skipped indices.
+@skip_indices||=[]
+ @skip_indices<<index
+ offset_by=@skip_indices.count{|skipped_idx|skipped_idx<index}
+ delete_at_index=index-offset_by
+ @graphql_metadata&&@graphql_metadata.delete_at(delete_at_index)
+ @graphql_result_data.delete_at(delete_at_index)
+end
# File 'lib/graphql/execution/interpreter/runtime/graphql_result.rb', line 151
+
+defset_child_result(idx,value)
+ if@skip_indices
+ offset_by=@skip_indices.count{|skipped_idx|skipped_idx<idx}
+ idx-=offset_by
+ end
+ @graphql_result_data[idx]=value.graphql_result_data
+ # If we encounter some part of this response that requires metadata tracking,
+# then create the metadata hash if necessary. It will be kept up-to-date after this.
+(@graphql_metadata||=@graphql_result_data.dup)[idx]=value
+ value
+end
+
+
+
+
+
+
+
+
+ #set_leaf(idx, value) ⇒ Object
+
+
+
+
+
+
+
+
+ This method is part of a private API.
+ You should avoid using this method if possible, as it may be removed or be changed in the future.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+141
+142
+143
+144
+145
+146
+147
+148
+149
+
+
+
# File 'lib/graphql/execution/interpreter/runtime/graphql_result.rb', line 141
+
+defset_leaf(idx,value)
+ if@skip_indices
+ offset_by=@skip_indices.count{|skipped_idx|skipped_idx<idx}
+ idx-=offset_by
+ end
+ @graphql_result_data[idx]=value
+ @graphql_metadata&&@graphql_metadata[idx]=value
+ value
+end
+
+
+
+
+
+
+
+
+ #values ⇒ Object
+
+
+
+
+
+
+
+
+ This method is part of a private API.
+ You should avoid using this method if possible, as it may be removed or be changed in the future.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+163
+164
+165
+
+
+
# File 'lib/graphql/execution/interpreter/runtime/graphql_result.rb', line 163
+
+defvalues
+ (@graphql_metadata||@graphql_result_data)
+end
+
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/api-doc/2.1.6/GraphQL/Execution/Interpreter/Runtime/GraphQLResultHash.html b/api-doc/2.1.6/GraphQL/Execution/Interpreter/Runtime/GraphQLResultHash.html
new file mode 100644
index 0000000000..9930dcb396
--- /dev/null
+++ b/api-doc/2.1.6/GraphQL/Execution/Interpreter/Runtime/GraphQLResultHash.html
@@ -0,0 +1,965 @@
+
+
+
+
+
+
+ Class: GraphQL::Execution::Interpreter::Runtime::GraphQLResultHash
+
+ — GraphQL Ruby API Documentation
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
# File 'lib/graphql/execution/interpreter/runtime/graphql_result.rb', line 97
+
+defmerge_into(into_result)
+ self.eachdo|key,value|
+ casevalue
+ whenGraphQLResultHash
+ next_into=into_result[key]
+ ifnext_into
+ value.merge_into(next_into)
+ else
+ into_result.set_child_result(key,value)
+ end
+ whenGraphQLResultArray
+ # There's no special handling of arrays because currently, there's no way to split the execution
+# of a list over several concurrent flows.
+into_result.set_child_result(key,value)
+ else
+ # We have to assume that, since this passed the `fields_will_merge` selection,
+# that the old and new values are the same.
+into_result.set_leaf(key,value)
+ end
+ end
+ @graphql_merged_into=into_result
+end
+ This method is part of a private API.
+ You should avoid using this method if possible, as it may be removed or be changed in the future.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+65
+66
+67
+68
+69
+70
+71
+72
+73
+74
+
+
+
# File 'lib/graphql/execution/interpreter/runtime/graphql_result.rb', line 65
+
+defset_child_result(key,value)
+ if(t=@graphql_merged_into)
+ t.set_child_result(key,value)
+ end
+ @graphql_result_data[key]=value.graphql_result_data
+ # If we encounter some part of this response that requires metadata tracking,
+# then create the metadata hash if necessary. It will be kept up-to-date after this.
+(@graphql_metadata||=@graphql_result_data.dup)[key]=value
+ value
+end
+
+
+
+
+
+
+
+
+ #set_leaf(key, value) ⇒ Object
+
+
+
+
+
+
+
+
+ This method is part of a private API.
+ You should avoid using this method if possible, as it may be removed or be changed in the future.
+
# File 'lib/graphql/execution/interpreter/runtime/graphql_result.rb', line 45
+
+defset_leaf(key,value)
+ # This is a hack.
+# Basically, this object is merged into the root-level result at some point.
+# But the problem is, some lazies are created whose closures retain reference to _this_
+# object. When those lazies are resolved, they cause an update to this object.
+#
+# In order to return a proper top-level result, we have to update that top-level result object.
+# In order to return a proper partial result (eg, for a directive), we have to update this object, too.
+# Yowza.
+if(t=@graphql_merged_into)
+ t.set_leaf(key,value)
+ end
+
+ @graphql_result_data[key]=value
+ # keep this up-to-date if it's been initialized
+@graphql_metadata&&@graphql_metadata[key]=value
+
+ value
+end
+
+
+
+
+
+
+
+
+ #values ⇒ Object
+
+
+
+
+
+
+
+
+ This method is part of a private API.
+ You should avoid using this method if possible, as it may be removed or be changed in the future.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+85
+86
+87
+
+
+
# File 'lib/graphql/execution/interpreter/runtime/graphql_result.rb', line 85
+
+defvalues
+ (@graphql_metadata||@graphql_result_data).values
+end
+
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/api-doc/2.1.6/GraphQL/Execution/Lazy.html b/api-doc/2.1.6/GraphQL/Execution/Lazy.html
new file mode 100644
index 0000000000..6e01357b2a
--- /dev/null
+++ b/api-doc/2.1.6/GraphQL/Execution/Lazy.html
@@ -0,0 +1,721 @@
+
+
+
+
+
+
+ Class: GraphQL::Execution::Lazy
+
+ — GraphQL Ruby API Documentation
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ This class is part of a private API.
+ You should avoid using this class if possible, as it may be removed or be changed in the future.
+
+
This wraps a value which is available, but not yet calculated, like a promise or future.
+
+
Calling #value will trigger calculation & return the “lazy” value.
+
+
This is an itty-bitty promise-like object, with key differences:
+- It has only two states, not-resolved and resolved
+- It has no error-catching functionality
# File 'lib/graphql/execution/lazy.rb', line 27
+
+defvalue
+ if!@resolved
+ @resolved=true
+ v=@get_value_func.call
+ ifv.is_a?(Lazy)
+ v=v.value
+ end
+ @value=v
+ end
+
+ # `SKIP` was made into a subclass of `GraphQL::Error` to improve runtime performance
+# (fewer clauses in a hot `case` block), but now it requires special handling here.
+# I think it's still worth it for the performance win, but if the number of special
+# cases grows, then maybe it's worth rethinking somehow.
+if@value.is_a?(StandardError)&&@value!=GraphQL::Execution::SKIP
+ raise@value
+ else
+ @value
+ end
+end
+
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/api-doc/2.1.6/GraphQL/Execution/Lazy/LazyMethodMap.html b/api-doc/2.1.6/GraphQL/Execution/Lazy/LazyMethodMap.html
new file mode 100644
index 0000000000..ae4af813c4
--- /dev/null
+++ b/api-doc/2.1.6/GraphQL/Execution/Lazy/LazyMethodMap.html
@@ -0,0 +1,583 @@
+
+
+
+
+
+
+ Class: GraphQL::Execution::Lazy::LazyMethodMap
+
+ — GraphQL Ruby API Documentation
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ This class is part of a private API.
+ You should avoid using this class if possible, as it may be removed or be changed in the future.
+
+
Schema uses this to match returned values to lazy resolution methods.
+Methods may be registered for classes, they apply to its subclasses also.
+The result of this lookup is cached for future resolutions.
+Instances of this class are thread-safe.
+ This method is part of a private API.
+ You should avoid using this method if possible, as it may be removed or be changed in the future.
+
+
Returns a new instance of ConcurrentishMap.
+
+
+
+
+
+
+
+
+
+
+
+
+
+63
+64
+65
+66
+67
+68
+
+
+
# File 'lib/graphql/execution/lazy/lazy_method_map.rb', line 63
+
+definitialize
+ @semaphore=Mutex.new
+ # Access to this hash must always be managed by the mutex
+# since it may be modified at runtime
+@storage={}
+end
+
+
+
+
+
+
+
+
+
+
Instance Method Details
+
+
+
+
+
+ #[]=(key, value) ⇒ Object
+
+
+
+
+
+
+
+
+ This method is part of a private API.
+ You should avoid using this method if possible, as it may be removed or be changed in the future.
+
Lookahead creates a uniform interface to inspect the forthcoming selections.
+
+
It assumes that the AST it’s working with is valid. (So, it’s safe to use
+during execution, but if you’re using it directly, be sure to validate first.)
+
+
A field may get access to its lookahead by adding extras: [:lookahead]
+to its configuration.
+
+
+
+
+
+
+
+
Examples:
+
+
+
looking ahead in a field
+
+
+
field:articles,[Types::Article],null:false,
+ extras:[:lookahead]
+
+# For example, imagine a faster database call
+# may be issued when only some fields are requested.
+#
+# Imagine that _full_ fetch must be made to satisfy `fullContent`,
+# we can look ahead to see if we need that field. If we do,
+# we make the expensive database call instead of the cheap one.
+defarticles(lookahead:)
+ iflookahead.selects?(:full_content)
+ fetch_full_articles(object)
+ else
+ fetch_preview_articles(object)
+ end
+end
Like #selection, but for all nodes.
+It returns a list of Lookaheads for all Selections
+
+
If arguments: is provided, each provided key/value will be matched
+against the arguments in each selection. This method will filter the selections
+if any of the given arguments: do not match the given selection.
True if this node has a selection on field_name.
+If field_name is a String, it is treated as a GraphQL-style (camelized)
+field name and used verbatim. If field_name is a Symbol, it is
+treated as a Ruby-style (underscored) name and camelized before comparing.
+
+
If arguments: is provided, each provided key/value will be matched
+against the arguments in the next selection. This method will return false
+if any of the given arguments: are not present and matching in the next selection.
+(But, the next selection may contain more than the given arguments.)
True if this node has a selection with alias matching alias_name.
+If alias_name is a String, it is treated as a GraphQL-style (camelized)
+field name and used verbatim. If alias_name is a Symbol, it is
+treated as a Ruby-style (underscored) name and camelized before comparing.
+
+
If arguments: is provided, each provided key/value will be matched
+against the arguments in the next selection. This method will return false
+if any of the given arguments: are not present and matching in the next selection.
+(But, the next selection may contain more than the given arguments.)
If a field’s resolve function returns a ExecutionError,
+the error will be inserted into the response’s "errors" key
+and the field will resolve to nil.
# File 'lib/graphql/integer_decoding_error.rb', line 12
+
+definitialize(value)
+ @integer_value=value
+ super("Integer out of bounds: #{value}. \nConsider using GraphQL::Types::BigInt instead.")
+end
+
+
+
+
+
+
+
+
+
Instance Attribute Details
+
+
+
+
+
+
+ #integer_value ⇒ Object(readonly)
+
+
+
+
+
+
+
+
The value which couldn’t be decoded
+
+
+
+
+
+
+
+
+
+
+
+
+
+10
+11
+12
+
+
+
# File 'lib/graphql/integer_decoding_error.rb', line 10
+
+definteger_value
+ @integer_value
+end
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/api-doc/2.1.6/GraphQL/IntegerEncodingError.html b/api-doc/2.1.6/GraphQL/IntegerEncodingError.html
new file mode 100644
index 0000000000..0dda01e3b0
--- /dev/null
+++ b/api-doc/2.1.6/GraphQL/IntegerEncodingError.html
@@ -0,0 +1,520 @@
+
+
+
+
+
+
+ Exception: GraphQL::IntegerEncodingError
+
+ — GraphQL Ruby API Documentation
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
This query is used by graphql-client so don’t add the includeDeprecated
+argument for inputFields since the server may not support it. Two stage
+introspection queries will be required to handle this in clients.
# File 'lib/graphql/introspection/entry_points.rb', line 10
+
+def__schema
+ # Apply wrapping manually since this field isn't wrapped by instrumentation
+schema=@context.query.schema
+ schema_type=schema.introspection_system.types["__Schema"]
+ schema_type.wrap(schema,@context)
+end
+
+
+
+
+
+
+
+
+ #__type(name:) ⇒ Object
+
+
+
+
+
+
+
+
+
+
+
+17
+18
+19
+
+
+
# File 'lib/graphql/introspection/entry_points.rb', line 17
+
+def__type(name:)
+ context.warden.reachable_type?(name)?context.warden.get_type(name):nil
+end
+
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/api-doc/2.1.6/GraphQL/Introspection/EnumValueType.html b/api-doc/2.1.6/GraphQL/Introspection/EnumValueType.html
new file mode 100644
index 0000000000..6acf49eeed
--- /dev/null
+++ b/api-doc/2.1.6/GraphQL/Introspection/EnumValueType.html
@@ -0,0 +1,433 @@
+
+
+
+
+
+
+ Class: GraphQL::Introspection::EnumValueType
+
+ — GraphQL Ruby API Documentation
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
# File 'lib/graphql/introspection/input_value_type.rb', line 20
+
+defdefault_value
+ if@object.default_value?
+ value=@object.default_value
+ ifvalue.nil?
+ 'null'
+ else
+ if(@object.type.kind.list?||(@object.type.kind.non_null?&&@object.type.of_type.kind.list?))&&!value.respond_to?(:map)
+ # This is a bit odd -- we expect the default value to be an application-style value, so we use coerce result below.
+# But coerce_result doesn't wrap single-item lists, which are valid inputs to list types.
+# So, apply that wrapper here if needed.
+value=[value]
+ end
+ coerced_default_value=@object.type.coerce_result(value,@context)
+ serialize_default_value(coerced_default_value,@object.type)
+ end
+ else
+ nil
+ end
+end
+
+
+
+
+
+
+
+
+ #is_deprecated ⇒ Object
+
+
+
+
+
+
+
+
+
+
+
+16
+17
+18
+
+
+
# File 'lib/graphql/introspection/input_value_type.rb', line 16
+
+defis_deprecated
+ !!@object.deprecation_reason
+end
+
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/api-doc/2.1.6/GraphQL/Introspection/SchemaType.html b/api-doc/2.1.6/GraphQL/Introspection/SchemaType.html
new file mode 100644
index 0000000000..4f70486f36
--- /dev/null
+++ b/api-doc/2.1.6/GraphQL/Introspection/SchemaType.html
@@ -0,0 +1,645 @@
+
+
+
+
+
+
+ Class: GraphQL::Introspection::SchemaType
+
+ — GraphQL Ruby API Documentation
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
# File 'lib/graphql/invalid_name_error.rb', line 5
+
+definitialize(name,valid_regex)
+ @name=name
+ @valid_regex=valid_regex
+ super("Names must match #{@valid_regex.inspect} but '#{@name}' does not")
+end
+
+
+
+
+
+
+
+
+
Instance Attribute Details
+
+
+
+
+
+
+ #name ⇒ Object(readonly)
+
+
+
+
+
+
+
+
Returns the value of attribute name.
+
+
+
+
+
+
+
+
+
+
+
+
+
+4
+5
+6
+
+
+
# File 'lib/graphql/invalid_name_error.rb', line 4
+
+defname
+ @name
+end
+
+
+
+
+
+
+
+
+
+
+ #valid_regex ⇒ Object(readonly)
+
+
+
+
+
+
+
+
Returns the value of attribute valid_regex.
+
+
+
+
+
+
+
+
+
+
+
+
+
+4
+5
+6
+
+
+
# File 'lib/graphql/invalid_name_error.rb', line 4
+
+defvalid_regex
+ @valid_regex
+end
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/api-doc/2.1.6/GraphQL/InvalidNullError.html b/api-doc/2.1.6/GraphQL/InvalidNullError.html
new file mode 100644
index 0000000000..e3b9afacc7
--- /dev/null
+++ b/api-doc/2.1.6/GraphQL/InvalidNullError.html
@@ -0,0 +1,883 @@
+
+
+
+
+
+
+ Exception: GraphQL::InvalidNullError
+
+ — GraphQL Ruby API Documentation
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
# File 'lib/graphql.rb', line 23
+
+definitialize(message)
+ message+="
+
+This is probably a bug in GraphQL-Ruby, please report this error on GitHub: https://github.com/rmosolgo/graphql-ruby/issues/new?template=bug_report.md"
+ super(message)
+end
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/api-doc/2.1.6/GraphQL/Language.html b/api-doc/2.1.6/GraphQL/Language.html
new file mode 100644
index 0000000000..9ff7e7fb45
--- /dev/null
+++ b/api-doc/2.1.6/GraphQL/Language.html
@@ -0,0 +1,236 @@
+
+
+
+
+
+
+ Module: GraphQL::Language
+
+ — GraphQL Ruby API Documentation
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
Remove leading and trailing whitespace from a block string.
+See “Block Strings” in https://github.com/facebook/graphql/blob/master/spec/Section%202%20–%20Language.md
# File 'lib/graphql/language/document_from_schema_definition.rb', line 262
+
+defbuild_definition_nodes
+ dirs_to_build=warden.directives
+ if!include_built_in_directives
+ dirs_to_build=dirs_to_build.reject{|directive|directive.default_directive?}
+ end
+ definitions=build_directive_nodes(dirs_to_build)
+
+ type_nodes=build_type_definition_nodes(warden.reachable_types)
+
+ if@include_one_of
+ # This may have been set to true when iterating over all types
+definitions.concat(build_directive_nodes([GraphQL::Schema::Directive::OneOf]))
+ end
+
+ definitions.concat(type_nodes)
+ ifinclude_schema_node?
+ definitions.unshift(build_schema_node)
+ end
+
+ definitions
+end
# File 'lib/graphql/language/document_from_schema_definition.rb', line 44
+
+defbuild_schema_node
+ if!schema_respects_root_name_conventions?(@schema)
+ GraphQL::Language::Nodes::SchemaDefinition.new(
+ query:(q=warden.root_type_for_operation("query"))&&q.graphql_name,
+ mutation:(m=warden.root_type_for_operation("mutation"))&&m.graphql_name,
+ subscription:(s=warden.root_type_for_operation("subscription"))&&s.graphql_name,
+ directives:definition_directives(@schema,:schema_directives)
+ )
+ else
+ # A plain `schema ...` _must_ include root type definitions.
+# If the only difference is directives, then you have to use `extend schema`
+GraphQL::Language::Nodes::SchemaExtension.new(directives:definition_directives(@schema,:schema_directives))
+ end
+end
%r{
+ #{BLOCK_QUOTE}
+ (?: [^"\\] | # Any characters that aren't a quote or slash
+ (?<!") ["]{1,2} (?!") | # Any quotes that don't have quotes next to them
+ \\"{0,3}(?!") | # A slash followed by <= 3 quotes that aren't followed by a quote
+ \\ | # A slash
+ "{1,2}(?!") # 1 or 2 " followed by something that isn't a quote
+ )*
+ (?:"")?
+ #{BLOCK_QUOTE}
+}xm
+
+
UNKNOWN_CHAR =
+
+
+
catch-all for anything else. must be at the bottom for precedence.
AbstractNode is the base class for all nodes in a GraphQL AST.
+
+
It provides some APIs for working with ASTs:
+- children returns all AST nodes attached to this one. Used for tree traversal.
+- scalars returns all scalar (Ruby) values attached to this one. Used for comparing nodes.
+- to_query_string turns an AST node into a GraphQL string
# File 'lib/graphql/language/nodes.rb', line 119
+
+defdelete_child(previous_child)
+ # Figure out which list `previous_child` may be found in
+method_name=previous_child.children_method_name
+ # Copy that list, and delete previous_child
+new_children=public_send(method_name).dup
+ new_children.delete(previous_child)
+ # Copy this node, but with the new list of children:
+copy_of_self=merge(method_name=>new_children)
+ # Return the copy:
+copy_of_self
+end
+
+
+
+
+
+
+
+
+ #initialize_copy(other) ⇒ Object
+
+
+
+
+
+
+
+
This might be unnecessary, but its easiest to add it here.
# File 'lib/graphql/language/nodes.rb', line 97
+
+defreplace_child(previous_child,new_child)
+ # Figure out which list `previous_child` may be found in
+method_name=previous_child.children_method_name
+ # Get the value from this (original) node
+prev_children=public_send(method_name)
+ ifprev_children.is_a?(Array)
+ # Copy that list, and replace `previous_child` with `new_child`
+# in the list.
+new_children=prev_children.dup
+ prev_idx=new_children.index(previous_child)
+ new_children[prev_idx]=new_child
+ else
+ # Use the new value for the given attribute
+new_children=new_child
+ end
+ # Copy this node, but with the new child value
+copy_of_self=merge(method_name=>new_children)
+ # Return the copy:
+copy_of_self
+end
A custom printer used to print sanitized queries. It inlines provided variables
+within the query for facilitate logging and analysis of queries.
+
+
The printer returns nil if the query is invalid.
+
+
Since the GraphQL Ruby AST for a GraphQL query doesnt contain any reference
+on the type of fields or arguments, we have to track the current object, field
+and input type while printing the query.
Indicates whether or not to redact non-null values for the given argument. Defaults to redacting all strings
+arguments but this can be customized by subclasses.
+
+
+
+
+
+
+
Returns:
+
+
+
+
+
+ (Boolean)
+
+
+
+
+
+
+
+
+
+
+
+
+
+63
+64
+65
+66
+67
+
+
+
# File 'lib/graphql/language/sanitized_printer.rb', line 63
+
+defredact_argument_value?(argument,value)
+ # Default to redacting any strings or custom scalars encoded as strings
+type=argument.type.unwrap
+ value.is_a?(String)&&type.kind.scalar?&&(type.graphql_name=="String"||!type.default_scalar?)
+end
# File 'lib/graphql/language/static_visitor.rb', line 26
+
+defself.make_visit_methods(ast_node_class)
+ node_method=ast_node_class.visit_method
+ children_of_type=ast_node_class.children_of_type
+ child_visit_method=:"#{node_method}_children"
+
+ class_eval(<<-RUBY,__FILE__,__LINE__+1)
+ # The default implementation for visiting an AST node.
+ # It doesn't _do_ anything, but it continues to visiting the node's children.
+ # To customize this hook, override one of its make_visit_methods (or the base method?)
+ # in your subclasses.
+ #
+ # @param node [GraphQL::Language::Nodes::AbstractNode] the node being visited
+ # @param parent [GraphQL::Language::Nodes::AbstractNode, nil] the previously-visited node, or `nil` if this is the root node.
+ # @return [void]
+ def #{node_method}(node, parent)
+ #{
+ ifmethod_defined?(child_visit_method)
+ "#{child_visit_method}(node)"
+ elsifchildren_of_type
+ children_of_type.mapdo|child_accessor,child_class|
+ "node.#{child_accessor}.each do |child_node|
+ #{child_class.visit_method}(child_node, node)
+ end"
+ end.join("\n")
+ else
+ ""
+ end
+ }
+ end
+ RUBY
+end
# File 'lib/graphql/language/static_visitor.rb', line 101
+
+defon_operation_definition_children(new_node)
+ new_node.variables.eachdo|arg_node|
+ on_variable_definition(arg_node,new_node)
+ end
+ visit_directives(new_node)
+ visit_selections(new_node)
+end
+
+
+
+
+
+
+
+
+ #visit ⇒ void
+
+
+
+
+
+
+
+
This method returns an undefined value.
Visit document and all children
+
+
+
+
+
+
+
+
+
+
+
+
+
+13
+14
+15
+16
+17
+18
+19
+20
+21
+22
+23
+
+
+
# File 'lib/graphql/language/static_visitor.rb', line 13
+
+defvisit
+ # `@document` may be any kind of node:
+visit_method=@document.visit_method
+ result=public_send(visit_method,@document,nil)
+ @result=ifresult.is_a?(Array)
+ result.first
+ else
+ # The node wasn't modified
+@document
+ end
+end
Depth-first traversal through the tree, calling hooks at each stop.
+
+
+
+
+
+
+
+
Examples:
+
+
+
Create a visitor counting certain field names
+
+
+
classNameCounter<GraphQL::Language::Visitor
+ definitialize(document,field_name)
+ super(document)
+ @field_name=field_name
+ @count=0
+ end
+
+ attr_reader:count
+
+ defon_field(node,parent)
+ # if this field matches our search, increment the counter
+ifnode.name==@field_name
+ @count+=1
+ end
+ # Continue visiting subfields:
+super
+ end
+end
+
+# Initialize a visitor
+visitor=NameCounter.new(document,"name")
+# Run it
+visitor.visit
+# Check the result
+visitor.count
+# => 3
# File 'lib/graphql/language/visitor.rb', line 65
+
+defself.make_visit_methods(ast_node_class)
+ node_method=ast_node_class.visit_method
+ children_of_type=ast_node_class.children_of_type
+ child_visit_method=:"#{node_method}_children"
+
+ class_eval(<<-RUBY,__FILE__,__LINE__+1)
+ # The default implementation for visiting an AST node.
+ # It doesn't _do_ anything, but it continues to visiting the node's children.
+ # To customize this hook, override one of its make_visit_methods (or the base method?)
+ # in your subclasses.
+ #
+ # @param node [GraphQL::Language::Nodes::AbstractNode] the node being visited
+ # @param parent [GraphQL::Language::Nodes::AbstractNode, nil] the previously-visited node, or `nil` if this is the root node.
+ # @return [Array, nil] If there were modifications, it returns an array of new nodes, otherwise, it returns `nil`.
+ def #{node_method}(node, parent)
+ if node.equal?(DELETE_NODE)
+ # This might be passed to `super(DELETE_NODE, ...)`
+ # by a user hook, don't want to keep visiting in that case.
+ [node, parent]
+ else
+ new_node = node
+ #{
+ ifmethod_defined?(child_visit_method)
+ "new_node = #{child_visit_method}(new_node)"
+ elsifchildren_of_type
+ children_of_type.mapdo|child_accessor,child_class|
+ "node.#{child_accessor}.each do |child_node|
+ new_child_and_node = #{child_class.visit_method}_with_modifications(child_node, new_node)
+ # Reassign `node` in case the child hook makes a modification
+ if new_child_and_node.is_a?(Array)
+ new_node = new_child_and_node[1]
+ end
+ end"
+ end.join("\n")
+ else
+ ""
+ end
+ }
+
+ if new_node.equal?(node)
+ [node, parent]
+ else
+ [new_node, parent]
+ end
+ end
+ end
+
+ def #{node_method}_with_modifications(node, parent)
+ new_node_and_new_parent = #{node_method}(node, parent)
+ apply_modifications(node, parent, new_node_and_new_parent)
+ end
+ RUBY
+end
# File 'lib/graphql/language/visitor.rb', line 119
+
+defon_document_children(document_node)
+ new_node=document_node
+ document_node.children.eachdo|child_node|
+ visit_method=:"#{child_node.visit_method}_with_modifications"
+ new_child_and_node=public_send(visit_method,child_node,new_node)
+ # Reassign `node` in case the child hook makes a modification
+ifnew_child_and_node.is_a?(Array)
+ new_node=new_child_and_node[1]
+ end
+ end
+ new_node
+end
# File 'lib/graphql/language/visitor.rb', line 132
+
+defon_field_children(new_node)
+ new_node.arguments.eachdo|arg_node|# rubocop:disable Development/ContextIsPassedCop
+new_child_and_node=on_argument_with_modifications(arg_node,new_node)
+ # Reassign `node` in case the child hook makes a modification
+ifnew_child_and_node.is_a?(Array)
+ new_node=new_child_and_node[1]
+ end
+ end
+ new_node=visit_directives(new_node)
+ new_node=visit_selections(new_node)
+ new_node
+end
+
+
+
+
+
+
+
+
+ #on_fragment_definition_children(new_node) ⇒ Object
+
+
+
+ Also known as:
+ on_inline_fragment_children
+
+
+
+
+
# File 'lib/graphql/language/visitor.rb', line 184
+
+defon_operation_definition_children(new_node)
+ new_node.variables.eachdo|arg_node|
+ new_child_and_node=on_variable_definition_with_modifications(arg_node,new_node)
+ # Reassign `node` in case the child hook makes a modification
+ifnew_child_and_node.is_a?(Array)
+ new_node=new_child_and_node[1]
+ end
+ end
+ new_node=visit_directives(new_node)
+ new_node=visit_selections(new_node)
+ new_node
+end
+
+
+
+
+
+
+
+
+ #visit ⇒ void
+
+
+
+
+
+
+
+
This method returns an undefined value.
Visit document and all children
+
+
+
+
+
+
+
+
+
+
+
+
+
+52
+53
+54
+55
+56
+57
+58
+59
+60
+61
+62
+
+
+
# File 'lib/graphql/language/visitor.rb', line 52
+
+defvisit
+ # `@document` may be any kind of node:
+visit_method=:"#{@document.visit_method}_with_modifications"
+ result=public_send(visit_method,@document,nil)
+ @result=ifresult.is_a?(Array)
+ result.first
+ else
+ # The node wasn't modified
+@document
+ end
+end
# File 'lib/graphql/language/visitor.rb', line 145
+
+defvisit_directives(new_node)
+ new_node.directives.eachdo|dir_node|
+ new_child_and_node=on_directive_with_modifications(dir_node,new_node)
+ # Reassign `node` in case the child hook makes a modification
+ifnew_child_and_node.is_a?(Array)
+ new_node=new_child_and_node[1]
+ end
+ end
+ new_node
+end
A Connection wraps a list of items and provides cursor-based pagination over it.
+
+
Connections were introduced by Facebook’s Relay front-end framework, but
+proved to be generally useful for GraphQL APIs. When in doubt, use connections
+to serve lists (like Arrays, ActiveRecord::Relations) via GraphQL.
+
+
Unlike the previous connection implementation, these default to bidirectional pagination.
# File 'lib/graphql/pagination/connection.rb', line 69
+
+definitialize(items,parent:nil,field:nil,context:nil,first:nil,after:nil,max_page_size:NOT_CONFIGURED,default_page_size:NOT_CONFIGURED,last:nil,before:nil,edge_class:nil,arguments:nil)
+ @items=items
+ @parent=parent
+ @context=context
+ @field=field
+ @first_value=first
+ @after_value=after
+ @last_value=last
+ @before_value=before
+ @arguments=arguments
+ @edge_class=edge_class||self.class::Edge
+ # This is only true if the object was _initialized_ with an override
+# or if one is assigned later.
+@has_max_page_size_override=max_page_size!=NOT_CONFIGURED
+ @max_page_size=ifmax_page_size==NOT_CONFIGURED
+ nil
+ else
+ max_page_size
+ end
+ @has_default_page_size_override=default_page_size!=NOT_CONFIGURED
+ @default_page_size=ifdefault_page_size==NOT_CONFIGURED
+ nil
+ else
+ default_page_size
+ end
+ @was_authorized_by_scope_items=detect_was_authorized_by_scope_items
+end
+
+
+
+
+
+
+
+
+
Instance Attribute Details
+
+
+
+
+
+
+ #after_value ⇒ Object
+
+
+
+
+
+
+
+
Raw access to client-provided values. (max_page_size not applied to first or last.)
+
+
+
+
+
+
+
+
+
+
+
+
+
+36
+37
+38
+
+
+
# File 'lib/graphql/pagination/connection.rb', line 36
+
+defafter_value
+ @after_value
+end
# File 'lib/graphql/pagination/connection.rb', line 177
+
+deffield
+ @field
+end
+
+
+
+
+
+
+
+
+
+
+ #first ⇒ Integer?
+
+
+
+
+
+
+
+
Returns A clamped first value.
+(The underlying instance variable doesn’t have limits on it.)
+If neither first nor last is given, but default_page_size is
+present, default_page_size is used for first. If default_page_size
+is greater than max_page_size, it'll be clamped down to
+max_page_size. If default_page_size is nil, use max_page_size`.
+
+
+
+
+
+
+
Returns:
+
+
+
+
+
+ (Integer, nil)
+
+
+
+ —
+
A clamped first value.
+(The underlying instance variable doesn’t have limits on it.)
+If neither first nor last is given, but default_page_size is
+present, default_page_size is used for first. If default_page_size
+is greater than max_page_size, it'll be clamped down to
+max_page_size. If default_page_size is nil, use max_page_size`.
+
+
+
+
+
+
+
+
+
+
+
+
+143
+144
+145
+146
+147
+148
+149
+150
+151
+
+
+
# File 'lib/graphql/pagination/connection.rb', line 143
+
+deffirst
+ @first||=begin
+ capped=limit_pagination_argument(@first_value,max_page_size)
+ ifcapped.nil?&&last.nil?
+ capped=limit_pagination_argument(default_page_size,max_page_size)||max_page_size
+ end
+ capped
+ end
+end
+
+
+
+
+
+
+
+
+
+
+ #first_value ⇒ Object
+
+
+
+
+
+
+
+
Raw access to client-provided values. (max_page_size not applied to first or last.)
+
+
+
+
+
+
+
+
+
+
+
+
+
+36
+37
+38
+
+
+
# File 'lib/graphql/pagination/connection.rb', line 36
+
+deffirst_value
+ @first_value
+end
+
+
+
+
+
+
+
+
+
+
+ #items ⇒ Object(readonly)
+
+
+
+
+
+
+
+
Returns A list object, from the application. This is the unpaginated value passed into the connection.
+
+
+
+
+
+
+
Returns:
+
+
+
+
+
+ (Object)
+
+
+
+ —
+
A list object, from the application. This is the unpaginated value passed into the connection.
+
+
+
+
+
+
+
+
+
+
+
+
+19
+20
+21
+
+
+
# File 'lib/graphql/pagination/connection.rb', line 19
+
+defitems
+ @items
+end
+
+
+
+
+
+
+
+
+
+
+ #last ⇒ Integer?
+
+
+
+
+
+
+
+
Returns A clamped last value. (The underlying instance variable doesn’t have limits on it).
+
+
+
+
+
+
+
Returns:
+
+
+
+
+
+ (Integer, nil)
+
+
+
+ —
+
A clamped last value. (The underlying instance variable doesn’t have limits on it)
+
+
+
+
+
+
+
+
+
+
+
+
+164
+165
+166
+
+
+
# File 'lib/graphql/pagination/connection.rb', line 164
+
+deflast
+ @last||=limit_pagination_argument(@last_value,max_page_size)
+end
+
+
+
+
+
+
+
+
+
+
+ #last_value ⇒ Object
+
+
+
+
+
+
+
+
Raw access to client-provided values. (max_page_size not applied to first or last.)
+
+
+
+
+
+
+
+
+
+
+
+
+
+36
+37
+38
+
+
+
# File 'lib/graphql/pagination/connection.rb', line 36
+
+deflast_value
+ @last_value
+end
+
+
+
+
+
+
+
+
+
+
+ #parent ⇒ Object
+
+
+
+
+
+
+
+
Returns the object this collection belongs to.
+
+
+
+
+
+
+
Returns:
+
+
+
+
+
+ (Object)
+
+
+
+ —
+
the object this collection belongs to
+
+
+
+
+
+
+
+
+
+
+
+
+33
+34
+35
+
+
+
# File 'lib/graphql/pagination/connection.rb', line 33
+
+defparent
+ @parent
+end
+
+
+
+
+
+
+
+
+
+
Instance Method Details
+
+
+
+
+
+ #after ⇒ String?
+
+
+
+
+
+
+
+
Returns the client-provided cursor. "" is treated as nil.
+
+
+
+
+
+
+
Returns:
+
+
+
+
+
+ (String, nil)
+
+
+
+ —
+
the client-provided cursor. "" is treated as nil.
+
+
+
+
+
+
+
+
+
+
+
+
+48
+49
+50
+51
+52
+53
+54
+
+
+
# File 'lib/graphql/pagination/connection.rb', line 48
+
+defafter
+ ifdefined?(@after)
+ @after
+ else
+ @after=@after_value==""?nil:@after_value
+ end
+end
+
+
+
+
+
+
+
+
+ #before ⇒ String?
+
+
+
+
+
+
+
+
Returns the client-provided cursor. "" is treated as nil.
+
+
+
+
+
+
+
Returns:
+
+
+
+
+
+ (String, nil)
+
+
+
+ —
+
the client-provided cursor. "" is treated as nil.
+
+
+
+
+
+
+
+
+
+
+
+
+39
+40
+41
+42
+43
+44
+45
+
+
+
# File 'lib/graphql/pagination/connection.rb', line 39
+
+defbefore
+ ifdefined?(@before)
+ @before
+ else
+ @before=@before_value==""?nil:@before_value
+ end
+end
# File 'lib/graphql/pagination/connection.rb', line 218
+
+defcursor_for(item)
+ raisePaginationImplementationMissingError,"Implement #{self.class}#cursor_for(item) to return the cursor for #{item.inspect}"
+end
+
+
+
+
+
+
+
+
+ #default_page_size ⇒ Object
+
+
+
+
+
+
+
+
+
+
+
+123
+124
+125
+126
+127
+128
+129
+
+
+
# File 'lib/graphql/pagination/connection.rb', line 123
+
+defdefault_page_size
+ if@has_default_page_size_override
+ @default_page_size
+ else
+ context.schema.default_page_size
+ end
+end
# File 'lib/graphql/pagination/relation_connection.rb', line 13
+
+defhas_previous_page
+ if@has_previous_page.nil?
+ @has_previous_page=ifafter_offset&&after_offset>0
+ true
+ elsiflast
+ # See whether there are any nodes _before_ the current offset.
+# If there _is no_ current offset, then there can't be any nodes before it.
+# Assume that if the offset is positive, there are nodes before the offset.
+limited_nodes
+ !(@paged_nodes_offset.nil?||@paged_nodes_offset==0)
+ else
+ false
+ end
+ end
+ @has_previous_page
+end
# File 'lib/graphql/query.rb', line 98
+
+definitialize(schema,query_string=nil,query:nil,document:nil,context:nil,variables:nil,validate:true,static_validator:nil,subscription_topic:nil,operation_name:nil,root_value:nil,max_depth:schema.max_depth,max_complexity:schema.max_complexity,warden:nil)
+ # Even if `variables: nil` is passed, use an empty hash for simpler logic
+variables||={}
+ @schema=schema
+ @context=schema.context_class.new(query:self,object:root_value,values:context)
+ @warden=warden
+ @subscription_topic=subscription_topic
+ @root_value=root_value
+ @fragments=nil
+ @operations=nil
+ @validate=validate
+ self.static_validator=static_validatorifstatic_validator
+ context_tracers=(context?context.fetch(:tracers,[]):[])
+ @tracers=schema.tracers+context_tracers
+
+ # Support `ctx[:backtrace] = true` for wrapping backtraces
+ifcontext&&context[:backtrace]&&!@tracers.include?(GraphQL::Backtrace::Tracer)
+ ifschema.trace_class<=GraphQL::Tracing::CallLegacyTracers
+ context_tracers+=[GraphQL::Backtrace::Tracer]
+ @tracers<<GraphQL::Backtrace::Tracer
+ elsif!(current_trace.class<=GraphQL::Backtrace::Trace)
+ raise"Invariant: `backtrace: true` should have provided a trace class with Backtrace mixed in, but it didnt. (Found: #{current_trace.class.ancestors}). This is a bug in GraphQL-Ruby, please report it on GitHub."
+ end
+ end
+
+ ifcontext_tracers.any?&&!(schema.trace_class<=GraphQL::Tracing::CallLegacyTracers)
+ raiseArgumentError,"context[:tracers] are not supported without `trace_with(GraphQL::Tracing::CallLegacyTracers)` in the schema configuration, please add it."
+ end
+
+ @analysis_errors=[]
+ ifvariables.is_a?(String)
+ raiseArgumentError,"Query variables should be a Hash, not a String. Try JSON.parse to prepare variables."
+ else
+ @provided_variables=variables||{}
+ end
+
+ @query_string=query_string||query
+ @document=document
+
+ if@query_string&&@document
+ raiseArgumentError,"Query should only be provided a query string or a document, not both."
+ end
+
+ if@query_string&&!@query_string.is_a?(String)
+ raiseArgumentError,"Query string argument should be a String, got #{@query_string.class.name} instead."
+ end
+
+ # A two-layer cache of type resolution:
+# { abstract_type => { value => resolved_type } }
+@resolved_types_cache=Hash.newdo|h1,k1|
+ h1[k1]=Hash.newdo|h2,k2|
+ h2[k2]=@schema.resolve_type(k1,k2,@context)
+ end
+ end
+
+ # Trying to execute a document
+# with no operations returns an empty hash
+@ast_variables=[]
+ @mutation=false
+ @operation_name=operation_name
+ @prepared_ast=false
+ @validation_pipeline=nil
+ @max_depth=max_depth
+ @max_complexity=max_complexity
+
+ @result_values=nil
+ @executed=false
+
+ @logger=ifcontext&&context[:logger]==false
+ Logger.new(IO::NULL)
+ elsifcontext&&(l=context[:logger])
+ l
+ else
+ schema.default_logger
+ end
+end
+
+
+
+
+
+
+
+
+
Instance Attribute Details
+
+
+
+
+
+
+ #analysis_errors ⇒ Object
+
+
+
+
+
+
+
+
Returns the value of attribute analysis_errors.
+
+
+
+
+
+
+
+
+
+
+
+
+
+324
+325
+326
+
+
+
# File 'lib/graphql/query.rb', line 324
+
+defanalysis_errors
+ @analysis_errors
+end
+
+
+
+
+
+
+
+
+
+
+ #context ⇒ Object(readonly)
+
+
+
+
+
+
+
+
Returns the value of attribute context.
+
+
+
+
+
+
+
+
+
+
+
+
+
+28
+29
+30
+
+
+
# File 'lib/graphql/query.rb', line 28
+
+defcontext
+ @context
+end
+
+
+
+
+
+
+
+
+
+
+ #logger ⇒ Object(readonly)
+
+
+
+
+
+
+
+
Returns the value of attribute logger.
+
+
+
+
+
+
+
+
+
+
+
+
+
+380
+381
+382
+
+
+
# File 'lib/graphql/query.rb', line 380
+
+deflogger
+ @logger
+end
+
+
+
+
+
+
+
+
+
+
+ #multiplex ⇒ Object
+
+
+
+
+
+
+
+
Returns the value of attribute multiplex.
+
+
+
+
+
+
+
+
+
+
+
+
+
+184
+185
+186
+
+
+
# File 'lib/graphql/query.rb', line 184
+
+defmultiplex
+ @multiplex
+end
+
+
+
+
+
+
+
+
+
+
+ #operation_name ⇒ nil, String
+
+
+
+
+
+
+
+
Returns The operation name provided by client or the one inferred from the document. Used to determine which operation to run.
+
+
+
+
+
+
+
Returns:
+
+
+
+
+
+ (nil, String)
+
+
+
+ —
+
The operation name provided by client or the one inferred from the document. Used to determine which operation to run.
+
+
+
+
+
+
+
+
+
+
+
+
+34
+35
+36
+
+
+
# File 'lib/graphql/query.rb', line 34
+
+defoperation_name
+ @operation_name
+end
# File 'lib/graphql/query.rb', line 65
+
+defdocument
+ # It's ok if this hasn't been assigned yet
+if@query_string||@document
+ with_prepared_ast{@document}
+ else
+ nil
+ end
+end
+
+
+
+
+
+
+
+
+ #executed? ⇒ Boolean
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
Returns:
+
+
+
+
+
+ (Boolean)
+
+
+
+
+
+
+
+
+
+
+
+
+
+235
+236
+237
+
+
+
# File 'lib/graphql/query.rb', line 235
+
+defexecuted?
+ @executed
+end
+
+
+
+
+
+
+
+
+ #fingerprint ⇒ String
+
+
+
+
+
+
+
+
This contains a few components:
+
+
+
The selected operation name (or anonymous)
+
The fingerprint of the query string
+
The number of given variables (for readability)
+
The fingerprint of the given variables
+
+
+
This fingerprint can be used to track runs of the same operation-variables combination over time.
+
+
+
+
+
+
+
Returns:
+
+
+
+
+
+ (String)
+
+
+
+ —
+
An opaque hash identifying this operation-variables combination
Use this when you need to do a scoped set inside a lazy-loaded (or batch-loaded)
+block of code.
+
+
+
+
+
+
+
+
Examples:
+
+
+
using scoped context inside a promise
+
+
+
scoped_ctx = context.scoped
+SomeBatchLoader.load(...).then do |thing|
+ # use a scoped_ctx which was created _before_ dataloading:
+ scoped_ctx.set!(:thing, thing)
+end
# File 'lib/graphql/query/context.rb', line 19
+
+defadd_error(error)
+ if!error.is_a?(ExecutionError)
+ raiseTypeError,"expected error to be a ExecutionError, but was #{error.class}"
+ end
+ errors<<error
+ nil
+end
# File 'lib/graphql/query/input_validation_result.rb', line 35
+
+defmerge_result!(path,inner_result)
+ returnifinner_result.nil?||inner_result.valid?
+
+ ifinner_result.problems
+ inner_result.problems.eachdo|p|
+ item_path=[path,*p["path"]]
+ add_problem(p["explanation"],item_path,message:p["message"],extensions:p["extensions"])
+ end
+ end
+ # It could have been explicitly set on inner_result (if it had no problems)
+@valid=false
+end
+
+
+
+
+
+
+
+
+ #valid? ⇒ Boolean
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
Returns:
+
+
+
+
+
+ (Boolean)
+
+
+
+
+
+
+
+
+
+
+
+
+
+18
+19
+20
+
+
+
# File 'lib/graphql/query/input_validation_result.rb', line 18
+
+defvalid?
+ @valid
+end
+
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/api-doc/2.1.6/GraphQL/Query/NullContext.html b/api-doc/2.1.6/GraphQL/Query/NullContext.html
new file mode 100644
index 0000000000..51fa33afcc
--- /dev/null
+++ b/api-doc/2.1.6/GraphQL/Query/NullContext.html
@@ -0,0 +1,611 @@
+
+
+
+
+
+
+ Class: GraphQL::Query::NullContext
+
+ — GraphQL Ruby API Documentation
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
# File 'lib/graphql/query/variable_validation_error.rb', line 21
+
+defto_h
+ # It is possible there are other extension items in this error, so handle
+# a one level deep merge explicitly. However beyond that only show the
+# latest value and problems.
+super.merge({"extensions"=>{"value"=>value,"problems"=>validation_result.problems}})do|key,oldValue,newValue|
+ ifoldValue.respond_to?(:merge)
+ oldValue.merge(newValue)
+ else
+ newValue
+ end
+ end
+end
+
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/api-doc/2.1.6/GraphQL/Query/Variables.html b/api-doc/2.1.6/GraphQL/Query/Variables.html
new file mode 100644
index 0000000000..55615d9a0d
--- /dev/null
+++ b/api-doc/2.1.6/GraphQL/Query/Variables.html
@@ -0,0 +1,482 @@
+
+
+
+
+
+
+ Class: GraphQL::Query::Variables
+
+ — GraphQL Ruby API Documentation
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
# File 'lib/graphql/query/variables.rb', line 13
+
+definitialize(ctx,ast_variables,provided_variables)
+ schema=ctx.schema
+ @context=ctx
+
+ @provided_variables=deep_stringify(provided_variables)
+ @errors=[]
+ @storage=ast_variables.each_with_object({})do|ast_variable,memo|
+ ifschema.validate_max_errors&&schema.validate_max_errors<=@errors.count
+ add_max_errors_reached_message
+ break
+ end
+ # Find the right value for this variable:
+# - First, use the value provided at runtime
+# - Then, fall back to the default value from the query string
+# If it's still nil, raise an error if it's required.
+variable_type=schema.type_from_ast(ast_variable.type,context:ctx)
+ ifvariable_type.nil?
+ # Pass -- it will get handled by a validator
+else
+ variable_name=ast_variable.name
+ default_value=ast_variable.default_value
+ provided_value=@provided_variables[variable_name]
+ value_was_provided=@provided_variables.key?(variable_name)
+ max_errors=schema.validate_max_errors-@errors.countifschema.validate_max_errors
+ begin
+ validation_result=variable_type.validate_input(provided_value,ctx,max_errors:max_errors)
+ ifvalidation_result.valid?
+ ifvalue_was_provided
+ # Add the variable if a value was provided
+memo[variable_name]=provided_value
+ elsifdefault_value!=nil
+ memo[variable_name]=ifdefault_value.is_a?(Language::Nodes::NullValue)
+ nil
+ else
+ default_value
+ end
+ end
+ end
+ rescueGraphQL::ExecutionError=>ex
+ # TODO: This should really include the path to the problematic node in the variable value
+# like InputValidationResults generated by validate_non_null_input but unfortunately we don't
+# have this information available in the coerce_input call chain. Note this path is the path
+# that appears under errors.extensions.problems.path and NOT the result path under errors.path.
+validation_result=GraphQL::Query::InputValidationResult.from_problem(ex.message)
+ end
+
+ if!validation_result.valid?
+ @errors<<GraphQL::Query::VariableValidationError.new(ast_variable,variable_type,provided_value,validation_result)
+ end
+ end
+ end
+end
+
+
+
+
+
+
+
+
+
Instance Attribute Details
+
+
+
+
+
+
+ #context ⇒ Object(readonly)
+
+
+
+
+
+
+
+
Returns the value of attribute context.
+
+
+
+
+
+
+
+
+
+
+
+
+
+11
+12
+13
+
+
+
# File 'lib/graphql/query/variables.rb', line 11
+
+defcontext
+ @context
+end
# File 'lib/graphql/relay/range_add.rb', line 37
+
+definitialize(collection:,item:,context:,parent:nil,edge_class:nil)
+ conn_class=context.schema.connections.wrapper_for(collection)
+ # The rest will be added by ConnectionExtension
+@connection=conn_class.new(collection,parent:parent,context:context,edge_class:edge_class)
+ # Check if this connection supports it, to support old versions of GraphQL-Pro
+@edge=if@connection.respond_to?(:range_add_edge)
+ @connection.range_add_edge(item)
+ else
+ @connection.edge_class.new(item,@connection)
+ end
+
+ @parent=parent
+end
+
+
+
+
+
+
+
+
+
Instance Attribute Details
+
+
+
+
+
+
+ #connection ⇒ Object(readonly)
+
+
+
+
+
+
+
+
Returns the value of attribute connection.
+
+
+
+
+
+
+
+
+
+
+
+
+
+30
+31
+32
+
+
+
# File 'lib/graphql/relay/range_add.rb', line 30
+
+defconnection
+ @connection
+end
+
+
+
+
+
+
+
+
+
+
+ #edge ⇒ Object(readonly)
+
+
+
+
+
+
+
+
Returns the value of attribute edge.
+
+
+
+
+
+
+
+
+
+
+
+
+
+30
+31
+32
+
+
+
# File 'lib/graphql/relay/range_add.rb', line 30
+
+defedge
+ @edge
+end
+
+
+
+
+
+
+
+
+
+
+ #parent ⇒ Object(readonly)
+
+
+
+
+
+
+
+
Returns the value of attribute parent.
+
+
+
+
+
+
+
+
+
+
+
+
+
+30
+31
+32
+
+
+
# File 'lib/graphql/relay/range_add.rb', line 30
+
+defparent
+ @parent
+end
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/api-doc/2.1.6/GraphQL/RequiredImplementationMissingError.html b/api-doc/2.1.6/GraphQL/RequiredImplementationMissingError.html
new file mode 100644
index 0000000000..e4bd92b9ae
--- /dev/null
+++ b/api-doc/2.1.6/GraphQL/RequiredImplementationMissingError.html
@@ -0,0 +1,132 @@
+
+
+
+
+
+
+ Exception: GraphQL::RequiredImplementationMissingError
+
+ — GraphQL Ruby API Documentation
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
Identify (and auto-correct) any field configuration which duplicates
+the default null: true property.
+
+
null: true is default because nullable fields can always be converted
+to non-null fields (null: false) without a breaking change. (The opposite change, from null: false
+to null: true, change.)
+
+
+
+
+
+
+
+
Examples:
+
+
+
# Both of these define `name: String` in GraphQL:
+
+# bad
+field:name,String,null:true
+
+# good
+field:name,String
Identify (and auto-correct) any argument configuration which duplicates
+the default required: true property.
+
+
required: true is default because required arguments can always be converted
+to optional arguments (required: false) without a breaking change. (The opposite change, from required: false
+to required: true, change.)
+
+
+
+
+
+
+
+
Examples:
+
+
+
# Both of these define `id: ID!` in GraphQL:
+
+# bad
+argument:id,ID,required:true
+
+# good
+argument:id,ID
query analyzers for assessing incoming queries (including max depth & max complexity restrictions)
+
execution strategies for running incoming queries
+
+
+
Schemas start with root types, Schema.query, Schema.mutation and Schema.subscription.
+The schema will traverse the tree of fields & types, using those as starting points.
+Any undiscoverable types may be provided with the types configuration.
+
+
Schemas can restrict large incoming queries with max_depth and max_complexity configurations.
+(These configurations can be overridden by specific calls to Schema.execute)
+
+
Schemas can specify how queries should be executed against them.
+query_execution_strategy, mutation_execution_strategy and subscription_execution_strategy
+each apply to corresponding root types.
+
+
+
+
+
+
+
+
Examples:
+
+
+
defining a schema
+
+
+
classMySchema<GraphQL::Schema
+ queryQueryType
+ # If types are only connected by way of interfaces, they must be added here
+orphan_typesImageType,AudioType
+end
Call the given block at the right time, either: - Right away, if value is not registered with lazy_resolve - After resolving value, if it’s registered with lazy_resolve (eg, Promise).
# File 'lib/graphql/schema.rb', line 391
+
+defconnections
+ ifdefined?(@connections)
+ @connections
+ else
+ inherited_connections=find_inherited_value(:connections,nil)
+ # This schema is part of an inheritance chain which is using new connections,
+# make a new instance, so we don't pollute the upstream one.
+ifinherited_connections
+ @connections=Pagination::Connections.new(schema:self)
+ else
+ nil
+ end
+ end
+end
+ This method is part of a private API.
+ You should avoid using this method if possible, as it may be removed or be changed in the future.
+
+
Call the given block at the right time, either:
+- Right away, if value is not registered with lazy_resolve
+- After resolving value, if it’s registered with lazy_resolve (eg, Promise)
# File 'lib/graphql/schema.rb', line 1259
+
+defafter_lazy(value,&block)
+ iflazy?(value)
+ GraphQL::Execution::Lazy.newdo
+ result=sync_lazy(value)
+ # The returned result might also be lazy, so check it, too
+after_lazy(result,&block)
+ end
+ else
+ yield(value)ifblock_given?
+ end
+end
# File 'lib/graphql/schema.rb', line 205
+
+defbuild_trace_mode(mode)
+ casemode
+ when:default
+ # Use the superclass's default mode if it has one, or else start an inheritance chain at the built-in base class.
+base_class=(superclass.respond_to?(:trace_class_for)&&superclass.trace_class_for(mode))||GraphQL::Tracing::Trace
+ Class.new(base_class)do
+ includeDefaultTraceClass
+ end
+ when:default_backtrace
+ schema_base_class=trace_class_for(:default)
+ Class.new(schema_base_class)do
+ include(GraphQL::Backtrace::Trace)
+ end
+ else
+ # First, see if the superclass has a custom-defined class for this.
+# Then, if it doesn't, use this class's default trace
+base_class=(superclass.respond_to?(:trace_class_for)&&superclass.trace_class_for(mode,build:false))||trace_class_for(:default)
+ # Prepare the default trace class if it hasn't been initialized yet
+base_class||=(own_trace_modes[:default]=build_trace_mode(:default))
+ mods=trace_modules_for(mode)
+ ifbase_class<DefaultTraceClass
+ mods=trace_modules_for(:default)+mods
+ end
+ Class.new(base_class)do
+ mods.any?&&include(*mods)
+ end
+ end
+end
# File 'lib/graphql/schema.rb', line 762
+
+defdisable_introspection_entry_points
+ @disable_introspection_entry_points=true
+ # TODO: this clears the cache made in `def types`. But this is not a great solution.
+@introspection_system=nil
+end
# File 'lib/graphql/schema.rb', line 768
+
+defdisable_schema_introspection_entry_point
+ @disable_schema_introspection_entry_point=true
+ # TODO: this clears the cache made in `def types`. But this is not a great solution.
+@introspection_system=nil
+end
# File 'lib/graphql/schema.rb', line 774
+
+defdisable_type_introspection_entry_point
+ @disable_type_introspection_entry_point=true
+ # TODO: this clears the cache made in `def types`. But this is not a great solution.
+@introspection_system=nil
+end
# File 'lib/graphql/schema.rb', line 1188
+
+defexecute(query_str=nil,**kwargs)
+ ifquery_str
+ kwargs[:query]=query_str
+ end
+ # Some of the query context _should_ be passed to the multiplex, too
+multiplex_context=if(ctx=kwargs[:context])
+ {
+ backtrace:ctx[:backtrace],
+ tracers:ctx[:tracers],
+ trace:ctx[:trace],
+ dataloader:ctx[:dataloader],
+ trace_mode:ctx[:trace_mode],
+ }
+ else
+ {}
+ end
+ # Since we're running one query, don't run a multiplex-level complexity analyzer
+all_results=multiplex([kwargs],max_complexity:nil,context:multiplex_context)
+ all_results[0]
+end
# File 'lib/graphql/schema.rb', line 960
+
+defid_from_object(object,type,ctx)
+ raiseGraphQL::RequiredImplementationMissingError,"#{self.name}.id_from_object(object, type, ctx) must be implemented to create global ids (tried to create an id for `#{object.inspect}`)"
+end
# File 'lib/graphql/schema.rb', line 942
+
+definherited(child_class)
+ ifself==GraphQL::Schema
+ child_class.directives(default_directives.values)
+ child_class.extend(SubclassGetReferencesTo)
+ end
+ # Make sure the child class has these built out, so that
+# subclasses can be modified by later calls to `trace_with`
+own_trace_modes.eachdo|name,_class|
+ child_class.own_trace_modes[name]=child_class.build_trace_mode(name)
+ end
+ child_class.singleton_class.prepend(ResolveTypeWithType)
+ super
+end
# File 'lib/graphql/schema.rb', line 956
+
+defobject_from_id(node_id,ctx)
+ raiseGraphQL::RequiredImplementationMissingError,"#{self.name}.object_from_id(node_id, ctx) must be implemented to load by ID (tried to load from id `#{node_id}`)"
+end
# File 'lib/graphql/schema.rb', line 1251
+
+defquery_stack_error(query,err)
+ query.context.errors.push(GraphQL::ExecutionError.new("This query is too large to execute."))
+end
# File 'lib/graphql/schema.rb', line 539
+
+defreferences_to(to_type=nil,from:nil)
+ @own_references_to||={}
+ ifto_type
+ if!to_type.is_a?(String)
+ to_type=to_type.graphql_name
+ end
+
+ iffrom
+ refs=@own_references_to[to_type]||=[]
+ refs<<from
+ else
+ get_references_to(to_type)||EMPTY_ARRAY
+ end
+ else
+ # `@own_references_to` can be quite large for big schemas,
+# and generally speaking, we won't inherit any values.
+# So optimize the most common case -- don't create a duplicate Hash.
+inherited_value=find_inherited_value(:references_to,EMPTY_HASH)
+ ifinherited_value.any?
+ inherited_value.merge(@own_references_to)
+ else
+ @own_references_to
+ end
+ end
+end
# File 'lib/graphql/schema.rb', line 933
+
+defresolve_type(type,obj,ctx)
+ iftype.kind.object?
+ type
+ else
+ raiseGraphQL::RequiredImplementationMissingError,"#{self.name}.resolve_type(type, obj, ctx) must be implemented to use Union types or Interface types (tried to resolve: #{type.name})"
+ end
+end
Configure trace_class to be used whenever context: { trace_mode: mode_name } is requested.
+default_trace_mode is used when no trace_mode: ... is requested.
+
+
When a trace_class is added this way, it will not receive other modules added with trace_with(...)
+unless trace_mode is explicitly given. (This class will not recieve any default trace modules.)
+
+
Subclasses of the schema will use trace_class as a base class for this mode and those
+subclass also will not receive default tracing modules.
# File 'lib/graphql/schema.rb', line 1093
+
+deftrace_with(trace_mod,mode::default,**options)
+ ifmode.is_a?(Array)
+ mode.each{|m|trace_with(trace_mod,mode:m,**options)}
+ else
+ tc=own_trace_modes[mode]||=build_trace_mode(mode)
+ tc.include(trace_mod)
+ own_trace_modules[mode]<<trace_mod
+
+ ifmode==:default
+ # This module is being added as a default tracer. If any other mode classes
+# have already been created, but get their default behavior from a superclass,
+# Then mix this into this schema's subclass.
+# (But don't mix it into mode classes that aren't default-based.)
+own_trace_modes.eachdo|other_mode_name,other_mode_class|
+ ifother_mode_class<DefaultTraceClass&&!(other_mode_class<trace_mod)
+ other_mode_class.include(trace_mod)
+ end
+ end
+ end
+ t_opts=trace_options_for(mode)
+ t_opts.merge!(options)
+ end
+ nil
+end
This hook is called when an object fails an authorized? check.
+You might report to your bug tracker here, so you can correct
+the field resolvers not to return unauthorized objects.
+
+
By default, this hook just replaces the unauthorized object with nil.
+
+
Whatever value is returned from this method will be used instead of the
+unauthorized object (accessible as unauthorized_error.object). If an
+error is raised, then nil will be used.
+
+
If you want to add an error to the "errors" key, raise a ExecutionError
+in this hook.
# File 'lib/graphql/schema/argument.rb', line 154
+
+defauthorized_as_type?(obj,value,ctx,as_type:)
+ ifvalue.nil?
+ returntrue
+ end
+
+ ifas_type.kind.non_null?
+ as_type=as_type.of_type
+ end
+
+ ifas_type.kind.list?
+ value.eachdo|v|
+ if!authorized_as_type?(obj,v,ctx,as_type:as_type.of_type)
+ returnfalse
+ end
+ end
+ elsifas_type.kind.input_object?
+ returnas_type.authorized?(obj,value,ctx)
+ end
+ # None of the early-return conditions were activated,
+# so this is authorized.
+true
+end
# File 'lib/graphql/schema/argument.rb', line 235
+
+defcoerce_into_values(parent_object,values,context,argument_values)
+ arg_name=graphql_name
+ arg_key=keyword
+ default_used=false
+
+ ifvalues.key?(arg_name)
+ value=values[arg_name]
+ elsifvalues.key?(arg_key)
+ value=values[arg_key]
+ elsifdefault_value?
+ value=default_value
+ default_used=true
+ else
+ # no value at all
+owner.validate_directive_argument(self,nil)
+ return
+ end
+
+ ifvalue.nil?&&replace_null_with_default?
+ value=default_value
+ default_used=true
+ end
+
+ loaded_value=nil
+ coerced_value=begin
+ type.coerce_input(value,context)
+ rescueStandardError=>err
+ context.schema.handle_or_reraise(context,err)
+ end
+
+ # If this isn't lazy, then the block returns eagerly and assigns the result here
+# If it _is_ lazy, then we write the lazy to the hash, then update it later
+argument_values[arg_key]=context.query.after_lazy(coerced_value)do|resolved_coerced_value|
+ owner.validate_directive_argument(self,resolved_coerced_value)
+ prepared_value=begin
+ prepare_value(parent_object,resolved_coerced_value,context:context)
+ rescueStandardError=>err
+ context.schema.handle_or_reraise(context,err)
+ end
+
+ ifloads&&!from_resolver?
+ loaded_value=begin
+ load_and_authorize_value(owner,prepared_value,context)
+ rescueStandardError=>err
+ context.schema.handle_or_reraise(context,err)
+ end
+ end
+
+ maybe_loaded_value=loaded_value||prepared_value
+ context.query.after_lazy(maybe_loaded_value)do|resolved_loaded_value|
+ # TODO code smell to access such a deeply-nested constant in a distant module
+argument_values[arg_key]=GraphQL::Execution::Interpreter::ArgumentValue.new(
+ value:resolved_loaded_value,
+ definition:self,
+ default_used:default_used,
+ )
+ end
+ end
+end
# File 'lib/graphql/schema/argument.rb', line 208
+
+defprepare_value(obj,value,context:nil)
+ ifvalue.is_a?(GraphQL::Schema::InputObject)
+ value=value.prepare
+ end
+
+ Schema::Validator.validate!(validators,obj,context,value)
+
+ if@prepare.nil?
+ value
+ elsif@prepare.is_a?(String)||@prepare.is_a?(Symbol)
+ ifobj.nil?
+ # The problem here is, we _used to_ prepare while building variables.
+# But now we don't have the runtime object there.
+#
+# This will have to be called later, when the runtime object _is_ available.
+value
+ else
+ obj.public_send(@prepare,value)
+ end
+ elsif@prepare.respond_to?(:call)
+ @prepare.call(value,context||obj.context)
+ else
+ raise"Invalid prepare for #{@owner.name}.name: #{@prepare.inspect}"
+ end
+end
# File 'lib/graphql/schema/argument.rb', line 187
+
+deftype
+ @type||=begin
+ parsed_type=begin
+ Member::BuildType.parse_type(@type_expr,null:@null)
+ rescueStandardError=>err
+ raiseArgumentError,"Couldn't build type for Argument #{@owner.name}.#{name}: #{err.class.name}: #{err.message}",err.backtrace
+ end
+ # Use the setter method to get validations
+self.type=parsed_type
+ end
+end
# File 'lib/graphql/schema/argument.rb', line 177
+
+deftype=(new_type)
+ validate_input_type(new_type)
+ # This isn't true for LateBoundTypes, but we can assume those will
+# be updated via this codepath later in schema setup.
+ifnew_type.respond_to?(:non_null?)
+ validate_deprecated_or_optional(null:!new_type.non_null?,deprecation_reason:deprecation_reason)
+ end
+ @type=new_type
+end
# File 'lib/graphql/schema/argument.rb', line 334
+
+defvalidate_default_value
+ coerced_default_value=begin
+ # This is weird, but we should accept single-item default values for list-type arguments.
+# If we used `coerce_isolated_input` below, it would do this for us, but it's not really
+# the right thing here because we expect default values in application format (Ruby values)
+# not GraphQL format (scalar values).
+#
+# But I don't think Schema::List#coerce_result should apply wrapping to single-item lists.
+prepped_default_value=ifdefault_value.nil?
+ nil
+ elsif(type.kind.list?||(type.kind.non_null?&&type.of_type.list?))&&!default_value.respond_to?(:map)
+ [default_value]
+ else
+ default_value
+ end
+
+ type.coerce_isolated_result(prepped_default_value)unlessprepped_default_value.nil?
+ rescueGraphQL::Schema::Enum::UnresolvedValueError
+ # It raises this, which is helpful at runtime, but not here...
+default_value
+ end
+ res=type.valid_isolated_input?(coerced_default_value)
+ if!res
+ raiseInvalidDefaultValueError.new(self)
+ end
+end
+
+
+
+
+
+
+
+
+ #visible?(context) ⇒ Boolean
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
Returns:
+
+
+
+
+
+ (Boolean)
+
+
+
+
+
+
+
+
+
+
+
+
+
+146
+147
+148
+
+
+
# File 'lib/graphql/schema/argument.rb', line 146
+
+defvisible?(context)
+ true
+end
+
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/api-doc/2.1.6/GraphQL/Schema/Argument/InvalidDefaultValueError.html b/api-doc/2.1.6/GraphQL/Schema/Argument/InvalidDefaultValueError.html
new file mode 100644
index 0000000000..cd7d6727a2
--- /dev/null
+++ b/api-doc/2.1.6/GraphQL/Schema/Argument/InvalidDefaultValueError.html
@@ -0,0 +1,214 @@
+
+
+
+
+
+
+ Exception: GraphQL::Schema::Argument::InvalidDefaultValueError
+
+ — GraphQL Ruby API Documentation
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
Returns a new instance of InvalidDefaultValueError.
+
+
+
+
+
+
+
+
+
+
+
+
+
+362
+363
+364
+365
+
+
+
# File 'lib/graphql/schema/argument.rb', line 362
+
+definitialize(argument)
+ message="`#{argument.path}` has an invalid default value: `#{argument.default_value.inspect}` isn't accepted by `#{argument.type.to_type_signature}`; update the default value or the argument type."
+ super(message)
+end
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/api-doc/2.1.6/GraphQL/Schema/Base64Encoder.html b/api-doc/2.1.6/GraphQL/Schema/Base64Encoder.html
new file mode 100644
index 0000000000..d6bdccc2cb
--- /dev/null
+++ b/api-doc/2.1.6/GraphQL/Schema/Base64Encoder.html
@@ -0,0 +1,276 @@
+
+
+
+
+
+
+ Module: GraphQL::Schema::Base64Encoder
+
+ — GraphQL Ruby API Documentation
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ This class is part of a private API.
+ You should avoid using this class if possible, as it may be removed or be changed in the future.
+
+
Wrap a user-provided hash of resolution behavior for easy access at runtime.
+
+
Coerce scalar values by:
+- Checking for a function in the map like { Date: { coerce_input: ->(val, ctx) { ... }, coerce_result: ->(val, ctx) { ... } } }
+- Falling back to a passthrough
+
+
Interface/union resolution can be provided as a resolve_type: key.
# File 'lib/graphql/schema/build_from_definition/resolve_map.rb', line 23
+
+definitialize(user_resolve_hash)
+ @resolve_hash=Hash.newdo|h,k|
+ # For each type name, provide a new hash if one wasn't given:
+h[k]=Hash.newdo|h2,k2|
+ ifk2=="coerce_input"||k2=="coerce_result"
+ # This isn't an object field, it's a scalar coerce function.
+# Use a passthrough
+NullScalarCoerce
+ else
+ # For each field, provide a resolver that will
+# make runtime checks & replace itself
+h2[k2]=DefaultResolve.new(h2,k2)
+ end
+ end
+ end
+ @user_resolve_hash=user_resolve_hash
+ # User-provided resolve functions take priority over the default:
+@user_resolve_hash.eachdo|type_name,fields|
+ type_name_s=type_name.to_s
+ casefields
+ whenHash
+ fields.eachdo|field_name,resolve_fn|
+ @resolve_hash[type_name_s][field_name.to_s]=resolve_fn
+ end
+ whenProc
+ # for example, "resolve_type"
+@resolve_hash[type_name_s]=fields
+ else
+ raiseArgumentError,"Unexpected resolve hash value for #{type_name.inspect}: #{fields.inspect} (#{fields.class})"
+ end
+ end
+
+ # Check the normalized hash, not the user input:
+if@resolve_hash.key?("resolve_type")
+ define_singleton_method:resolve_typedo|type,obj,ctx|
+ @resolve_hash.fetch("resolve_type").call(type,obj,ctx)
+ end
+ end
+end
+ This method is part of a private API.
+ You should avoid using this method if possible, as it may be removed or be changed in the future.
+
+
Make some runtime checks about
+how obj implements the field_name.
+
+
Create a new resolve function according to that implementation, then:
+ - update field_map with this implementation
+ - call the implementation now (to satisfy this field execution)
+
+
If obj doesn’t implement field_name, raise an error.
{
+ QUERY:'Location adjacent to a query operation.',
+ MUTATION:'Location adjacent to a mutation operation.',
+ SUBSCRIPTION:'Location adjacent to a subscription operation.',
+ FIELD:'Location adjacent to a field.',
+ FRAGMENT_DEFINITION:'Location adjacent to a fragment definition.',
+ FRAGMENT_SPREAD:'Location adjacent to a fragment spread.',
+ INLINE_FRAGMENT:'Location adjacent to an inline fragment.',
+ SCHEMA:'Location adjacent to a schema definition.',
+ SCALAR:'Location adjacent to a scalar definition.',
+ OBJECT:'Location adjacent to an object type definition.',
+ FIELD_DEFINITION:'Location adjacent to a field definition.',
+ ARGUMENT_DEFINITION:'Location adjacent to an argument definition.',
+ INTERFACE:'Location adjacent to an interface definition.',
+ UNION:'Location adjacent to a union definition.',
+ ENUM:'Location adjacent to an enum definition.',
+ ENUM_VALUE:'Location adjacent to an enum value definition.',
+ INPUT_OBJECT:'Location adjacent to an input object type definition.',
+ INPUT_FIELD_DEFINITION:'Location adjacent to an input object field definition.',
+ VARIABLE_DEFINITION:'Location adjacent to a variable definition.',
+}
# File 'lib/graphql/schema/directive.rb', line 114
+
+definitialize(owner,**arguments)
+ @owner=owner
+ assert_valid_owner
+ # It's be nice if we had the real context here, but we don't. What we _would_ get is:
+# - error handling
+# - lazy resolution
+# Probably, those won't be needed here, since these are configuration arguments,
+# not runtime arguments.
+@arguments=self.class.coerce_arguments(nil,arguments,Query::NullContext.instance)
+end
An example directive to show how you might interact with the runtime.
+
+
This directive might be used along with a server-side feature flag system like Flipper.
+
+
With that system, you could use this directive to exclude parts of a query
+if the current viewer doesn’t have certain flags enabled.
+(So, this flag would be for internal clients, like your iOS app, not third-party API clients.)
+
+
To use it, you have to implement .enabled?, for example:
+
+
+
+
+
+
+
+
Examples:
+
+
+
Implementing the Feature directive
+
+
+
# app/graphql/directives/feature.rb
+classDirectives::Feature<GraphQL::Schema::Directive::Feature
+ defself.enabled?(flag_name,_obj,context)
+ # Translate some GraphQL data for Ruby:
+flag_key=flag_name.underscore
+ current_user=context[:viewer]
+ # Check the feature flag however your app does it:
+MyFeatureFlags.enabled?(current_user,flag_key)
+ end
+end
+
+
+
Flagging a part of the query
+
+
+
viewer {
+ # This field only runs if `.enabled?("recommendationEngine", obj, context)`
+ # returns true. Otherwise, it's treated as if it didn't exist.
+ recommendations @feature(flag: "recommendationEngine") {
+ name
+ rating
+ }
+}
# File 'lib/graphql/schema/directive/feature.rb', line 60
+
+defself.enabled?(flag_name,object,context)
+ raiseGraphQL::RequiredImplementationMissingError,"Implement `.enabled?(flag_name, object, context)` to return true or false for the feature flag (#{flag_name.inspect})"
+end
# File 'lib/graphql/schema/directive/flagged.rb', line 9
+
+definitialize(target,**options)
+ iftarget.is_a?(Module)&&!target.ancestors.include?(VisibleByFlag)
+ # This is type class of some kind, `include` will put this module
+# in between the type class itself and its super class, so `super` will work fine
+target.include(VisibleByFlag)
+ elsif!target.is_a?(VisibleByFlag)
+ # This is an instance of a base class. `include` won't put this in front of the
+# base class implementation, so we need to `.prepend`.
+# `#visible?` could probably be moved to a module and then this could use `include` instead.
+target.class.prepend(VisibleByFlag)
+ end
+ super
+end
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/api-doc/2.1.6/GraphQL/Schema/Directive/Flagged/VisibleByFlag.html b/api-doc/2.1.6/GraphQL/Schema/Directive/Flagged/VisibleByFlag.html
new file mode 100644
index 0000000000..d1cea31444
--- /dev/null
+++ b/api-doc/2.1.6/GraphQL/Schema/Directive/Flagged/VisibleByFlag.html
@@ -0,0 +1,208 @@
+
+
+
+
+
+
+ Module: GraphQL::Schema::Directive::Flagged::VisibleByFlag
+
+ — GraphQL Ruby API Documentation
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
An example directive to show how you might interact with the runtime.
+
+
This directive takes the return value of the tagged part of the query,
+and if the named transform is whitelisted and applies to the return value,
+it’s applied by calling a method with that name.
# File 'lib/graphql/schema/enum.rb', line 154
+
+defcoerce_input(value_name,ctx)
+ all_values=ctx.warden?ctx.warden.enum_values(self):values.each_value
+
+ ifv=all_values.find{|val|val.graphql_name==value_name}
+ v.value
+ elsifv=all_values.find{|val|val.value==value_name}
+ # this is for matching default values, which are "inputs", but they're
+# the Ruby value, not the GraphQL string.
+v.value
+ else
+ nil
+ end
+end
# File 'lib/graphql/schema/enum.rb', line 38
+
+definitialize(enum_type)
+ @enum_type=enum_type
+ super("Enum types require at least one value, but #{enum_type.graphql_name} didn't provide any for this query. Make sure at least one value is defined and visible for this query.")
+end
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/api-doc/2.1.6/GraphQL/Schema/Enum/UnresolvedValueError.html b/api-doc/2.1.6/GraphQL/Schema/Enum/UnresolvedValueError.html
new file mode 100644
index 0000000000..293124dc98
--- /dev/null
+++ b/api-doc/2.1.6/GraphQL/Schema/Enum/UnresolvedValueError.html
@@ -0,0 +1,224 @@
+
+
+
+
+
+
+ Exception: GraphQL::Schema::Enum::UnresolvedValueError
+
+ — GraphQL Ruby API Documentation
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
# File 'lib/graphql/schema/enum.rb', line 26
+
+definitialize(value:,enum:,context:)
+ fix_message=", but this isn't a valid value for `#{enum.graphql_name}`. Update the field or resolver to return one of `#{enum.graphql_name}`'s values instead."
+ message=if(cp=context[:current_path])&&(cf=context[:current_field])
+ "`#{cf.path}` returned `#{value.inspect}` at `#{cp.join(".")}`#{fix_message}"
+ else
+ "`#{value.inspect}` was returned for `#{enum.graphql_name}`#{fix_message}"
+ end
+ super(message)
+end
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/api-doc/2.1.6/GraphQL/Schema/EnumValue.html b/api-doc/2.1.6/GraphQL/Schema/EnumValue.html
new file mode 100644
index 0000000000..fffa748abc
--- /dev/null
+++ b/api-doc/2.1.6/GraphQL/Schema/EnumValue.html
@@ -0,0 +1,897 @@
+
+
+
+
+
+
+ Class: GraphQL::Schema::EnumValue
+
+ — GraphQL Ruby API Documentation
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
You can extend this class to customize enum values in your schema.
+
+
+
+
+
+
+
+
Examples:
+
+
+
custom enum value class
+
+
+
# define a custom class:
+classCustomEnumValue<GraphQL::Schema::EnumValue
+ definitialize(*args)
+ # arguments to `value(...)` in Enum classes are passed here
+super
+ end
+end
+
+classBaseEnum<GraphQL::Schema::Enum
+ # use it for these enums:
+enum_value_classCustomEnumValue
+end
# File 'lib/graphql/schema/field.rb', line 583
+
+deftype
+ if@resolver_class
+ return_type=@return_type_expr||@resolver_class.type_expr
+ ifreturn_type.nil?
+ raiseMissingReturnTypeError,"Can't determine the return type for #{self.path} (it has `resolver: #{@resolver_class}`, perhaps that class is missing a `type ...` declaration, or perhaps its type causes a cyclical loading issue)"
+ end
+ nullable=@return_type_null.nil??@resolver_class.null:@return_type_null
+ Member::BuildType.parse_type(return_type,null:nullable)
+ else
+ @type||=Member::BuildType.parse_type(@return_type_expr,null:@return_type_null)
+ end
+rescueGraphQL::Schema::InvalidDocumentError,MissingReturnTypeError=>err
+ # Let this propagate up
+raiseerr
+rescueStandardError=>err
+ raiseMissingReturnTypeError,"Failed to build return type for #{@owner.graphql_name}.#{name} from #{@return_type_expr.inspect}: (#{err.class}) #{err.message}",err.backtrace
+end
# File 'lib/graphql/schema/field.rb', line 97
+
+defself.from_options(name=nil,type=nil,desc=nil,resolver:nil,mutation:nil,subscription:nil,**kwargs,&block)
+ if(resolver_class=resolver||mutation||subscription)
+ # Add a reference to that parent class
+kwargs[:resolver_class]=resolver_class
+ end
+
+ ifname
+ kwargs[:name]=name
+ end
+
+ if!type.nil?
+ ifdesc
+ ifkwargs[:description]
+ raiseArgumentError,"Provide description as a positional argument or `description:` keyword, but not both (#{desc.inspect}, #{kwargs[:description].inspect})"
+ end
+
+ kwargs[:description]=desc
+ kwargs[:type]=type
+ elsif(resolver||mutation)&&type.is_a?(String)
+ # The return type should be copied from the resolver, and the second positional argument is the description
+kwargs[:description]=type
+ else
+ kwargs[:type]=type
+ end
+ iftype.is_a?(Class)&&type<GraphQL::Schema::Mutation
+ raiseArgumentError,"Use `field #{name.inspect}, mutation: Mutation, ...` to provide a mutation to this field instead"
+ end
+ end
+ new(**kwargs,&block)
+end
# File 'lib/graphql/schema/field.rb', line 609
+
+defauthorized?(object,args,context)
+ if@resolver_class
+ # The resolver _instance_ will check itself during `resolve()`
+@resolver_class.authorized?(object,context)
+ else
+ ifargs.size>0
+ if(arg_values=context[:current_arguments])
+ # ^^ that's provided by the interpreter at runtime, and includes info about whether the default value was used or not.
+using_arg_values=true
+ arg_values=arg_values.argument_values
+ else
+ arg_values=args
+ using_arg_values=false
+ end
+
+ args=context.warden.arguments(self)
+ args.eachdo|arg|
+ arg_key=arg.keyword
+ ifarg_values.key?(arg_key)
+ arg_value=arg_values[arg_key]
+ ifusing_arg_values
+ ifarg_value.default_used?
+ # pass -- no auth required for default used
+next
+ else
+ application_arg_value=arg_value.value
+ ifapplication_arg_value.is_a?(GraphQL::Execution::Interpreter::Arguments)
+ application_arg_value.keyword_arguments
+ end
+ end
+ else
+ application_arg_value=arg_value
+ end
+
+ if!arg.authorized?(object,application_arg_value,context)
+ returnfalse
+ end
+ end
+ end
+ end
+ true
+ end
+end
+
+
+
+
+
+
+
+
+ #broadcastable? ⇒ Boolean?
+
+
+
+
+
+
+
+
If true, subscription updates with this field can be shared between viewers
# File 'lib/graphql/schema/field.rb', line 130
+
+defconnection?
+ if@connection.nil?
+ # Provide default based on type name
+return_type_name=if@return_type_expr
+ Member::BuildType.to_type_name(@return_type_expr)
+ elsif@resolver_class&&@resolver_class.type
+ Member::BuildType.to_type_name(@resolver_class.type)
+ else
+ # As a last ditch, try to force loading the return type:
+type.unwrap.name
+ end
+ @connection=return_type_name.end_with?("Connection")&&return_type_name!="Connection"
+ else
+ @connection
+ end
+end
Read extension instances from this field,
+or add new classes/options to be initialized on this field.
+Extensions are executed in the order they are added.
# File 'lib/graphql/schema/field.rb', line 441
+
+defextras(new_extras=nil)
+ ifnew_extras.nil?
+ # Read the value
+field_extras=@extras
+ if@resolver_class&&@resolver_class.extras.any?
+ field_extras+@resolver_class.extras
+ else
+ field_extras
+ end
+ else
+ if@extras.frozen?
+ @extras=@extras.dup
+ end
+ # Append to the set of extras on this field
+@extras.concat(new_extras)
+ end
+end
Returns Should we warn if this field’s name conflicts with a built-in method?.
+
+
+
+
+
+
+
Returns:
+
+
+
+
+
+ (Boolean)
+
+
+
+ —
+
Should we warn if this field’s name conflicts with a built-in method?
+
+
+
+
+
+
+
+
+
+
+
+
+189
+190
+191
+
+
+
# File 'lib/graphql/schema/field.rb', line 189
+
+defmethod_conflict_warning?
+ @method_conflict_warning
+end
+
+
+
+
+
+
+
+
+ #owner_type ⇒ Class
+
+
+
+
+
+
+
+
Returns The GraphQL type this field belongs to. (For fields defined on mutations, it’s the payload type).
+
+
+
+
+
+
+
Returns:
+
+
+
+
+
+ (Class)
+
+
+
+ —
+
The GraphQL type this field belongs to. (For fields defined on mutations, it’s the payload type)
+
+
+
+
+
+
+
+
+
+
+
+
+48
+49
+50
+51
+52
+53
+54
+55
+56
+
+
+
# File 'lib/graphql/schema/field.rb', line 48
+
+defowner_type
+ @owner_type||=ifowner.nil?
+ raiseGraphQL::InvariantError,"Field #{original_name.inspect} (graphql name: #{graphql_name.inspect}) has no owner, but all fields should have an owner. How did this happen?!"
+ elsifowner<GraphQL::Schema::Mutation
+ owner.payload_type
+ else
+ owner
+ end
+end
# File 'lib/graphql/schema/field.rb', line 148
+
+defscoped?
+ if!@scope.nil?
+ # The default was overridden
+@scope
+ elsif@return_type_expr
+ # Detect a list return type, but don't call `type` since that may eager-load an otherwise lazy-loaded type
+@return_type_expr.is_a?(Array)||
+ (@return_type_expr.is_a?(String)&&@return_type_expr.include?("["))||
+ connection?
+ elsif@resolver_class
+ resolver_type=@resolver_class.type_expr
+ resolver_type.is_a?(Array)||
+ (resolver_type.is_a?(String)&&resolver_type.include?("["))||
+ connection?
+ else
+ false
+ end
+end
+
+
+
+
+
+
+
+
+ #visible?(context) ⇒ Boolean
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
Returns:
+
+
+
+
+
+ (Boolean)
+
+
+
+
+
+
+
+
+
+
+
+
+
+601
+602
+603
+604
+605
+606
+607
+
+
+
# File 'lib/graphql/schema/field.rb', line 601
+
+defvisible?(context)
+ if@resolver_class
+ @resolver_class.visible?(context)
+ else
+ true
+ end
+end
+
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/api-doc/2.1.6/GraphQL/Schema/Field/ConnectionExtension.html b/api-doc/2.1.6/GraphQL/Schema/Field/ConnectionExtension.html
new file mode 100644
index 0000000000..024d2187cb
--- /dev/null
+++ b/api-doc/2.1.6/GraphQL/Schema/Field/ConnectionExtension.html
@@ -0,0 +1,432 @@
+
+
+
+
+
+
+ Class: GraphQL::Schema::Field::ConnectionExtension
+
+ — GraphQL Ruby API Documentation
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
# File 'lib/graphql/schema/field/connection_extension.rb', line 24
+
+defafter_resolve(value:,object:,arguments:,context:,memo:)
+ original_arguments=memo
+ # rename some inputs to avoid conflicts inside the block
+maybe_lazy=value
+ value=nil
+ context.query.after_lazy(maybe_lazy)do|resolved_value|
+ value=resolved_value
+ ifvalue.is_a?GraphQL::ExecutionError
+ # This isn't even going to work because context doesn't have ast_node anymore
+context.add_error(value)
+ nil
+ elsifvalue.nil?
+ nil
+ elsifvalue.is_a?(GraphQL::Pagination::Connection)
+ # update the connection with some things that may not have been provided
+value.context||=context
+ value.parent||=object.object
+ value.first_value||=original_arguments[:first]
+ value.after_value||=original_arguments[:after]
+ value.last_value||=original_arguments[:last]
+ value.before_value||=original_arguments[:before]
+ value.arguments||=original_arguments# rubocop:disable Development/ContextIsPassedCop -- unrelated .arguments method
+value.field||=field
+ iffield.has_max_page_size?&&!value.has_max_page_size_override?
+ value.max_page_size=field.max_page_size
+ end
+ iffield.has_default_page_size?&&!value.has_default_page_size_override?
+ value.default_page_size=field.default_page_size
+ end
+ ifcontext.schema.new_connections?&&(custom_t=context.schema.connections.edge_class_for_field(@field))
+ value.edge_class=custom_t
+ end
+ value
+ else
+ context.namespace(:connections)[:all_wrappers]||=context.schema.connections.all_wrappers
+ context.schema.connections.wrap(field,object.object,value,original_arguments,context)
+ end
+ end
+end
# File 'lib/graphql/schema/field/connection_extension.rb', line 7
+
+defapply
+ field.argument:after,"String","Returns the elements in the list that come after the specified cursor.",required:false
+ field.argument:before,"String","Returns the elements in the list that come before the specified cursor.",required:false
+ field.argument:first,"Int","Returns the first _n_ elements from the list.",required:false
+ field.argument:last,"Int","Returns the last _n_ elements from the list.",required:false
+end
Extend this class to make field-level customizations to resolve behavior.
+
+
When a extension is added to a field with extension(MyExtension), a MyExtension instance
+is created, and its hooks are applied whenever that field is called.
+
+
The instance is frozen so that instance variables aren’t modified during query execution,
+which could cause all kinds of issues due to race conditions.
If configured, these extras will be added to the field if they aren’t already present, but removed by from arguments before the field’s resolve is called.
If configured, these extras will be added to the field if they aren’t already present,
+but removed by from arguments before the field’s resolve is called.
+(The extras will be present for other extensions, though.)
# File 'lib/graphql/schema/has_single_input_argument.rb', line 6
+
+defresolve_with_support(**inputs)
+ ifinputs[:input].is_a?(InputObject)
+ input=inputs[:input].to_kwargs
+ else
+ input=inputs[:input]
+ end
+
+ new_extras=field?field.extras:[]
+ all_extras=self.class.extras+new_extras
+
+ # Transfer these from the top-level hash to the
+# shortcutted `input:` object
+all_extras.eachdo|ext|
+ # It's possible that the `extra` was not passed along by this point,
+# don't re-add it if it wasn't given here.
+ifinputs.key?(ext)
+ input[ext]=inputs[ext]
+ end
+ end
+
+ ifinput
+ # This is handled by Relay::Mutation::Resolve, a bit hacky, but here we are.
+input_kwargs=input.to_h
+ else
+ # Relay Classic Mutations with no `argument`s
+# don't require `input:`
+input_kwargs={}
+ end
+
+ ifinput_kwargs.any?
+ super(**input_kwargs)
+ else
+ super()
+ end
+end
+
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/api-doc/2.1.6/GraphQL/Schema/HasSingleInputArgument/ClassMethods.html b/api-doc/2.1.6/GraphQL/Schema/HasSingleInputArgument/ClassMethods.html
new file mode 100644
index 0000000000..76f15eac3a
--- /dev/null
+++ b/api-doc/2.1.6/GraphQL/Schema/HasSingleInputArgument/ClassMethods.html
@@ -0,0 +1,790 @@
+
+
+
+
+
+
+ Module: GraphQL::Schema::HasSingleInputArgument::ClassMethods
+
+ — GraphQL Ruby API Documentation
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
# File 'lib/graphql/schema/has_single_input_argument.rb', line 78
+
+defargument(*args,own_argument:false,**kwargs,&block)
+ it=input_type# make sure any inherited arguments are already added to it
+arg=super(*args,**kwargs,&block)
+
+ # This definition might be overriding something inherited;
+# if it is, remove the inherited definition so it's not confused at runtime as having multiple definitions
+prev_args=it.own_arguments[arg.graphql_name]
+ caseprev_args
+ whenGraphQL::Schema::Argument
+ ifprev_args.owner!=self
+ it.own_arguments.delete(arg.graphql_name)
+ end
+ whenArray
+ prev_args.reject!{|a|a.owner!=self}
+ ifprev_args.empty?
+ it.own_arguments.delete(arg.graphql_name)
+ end
+ end
+
+ it.add_argument(arg)
+ arg
+end
# File 'lib/graphql/schema/has_single_input_argument.rb', line 47
+
+defdummy
+ @dummy||=begin
+ d=Class.new(GraphQL::Schema::Resolver)
+ d.argument_class(self.argument_class)
+ # TODO make this lazier?
+d.argument(:input,input_type,description:"Parameters for #{self.graphql_name}")
+ d
+ end
+end
# File 'lib/graphql/schema/input_object.rb', line 21
+
+definitialize(arguments,ruby_kwargs:,context:,defaults_used:)
+ @context=context
+ @ruby_style_hash=ruby_kwargs
+ @arguments=arguments
+ # Apply prepares, not great to have it duplicated here.
+self.class.arguments(context).each_valuedo|arg_defn|
+ ruby_kwargs_key=arg_defn.keyword
+ if@ruby_style_hash.key?(ruby_kwargs_key)
+ # Weirdly, procs are applied during coercion, but not methods.
+# Probably because these methods require a `self`.
+ifarg_defn.prepare.is_a?(Symbol)||context.nil?
+ prepared_value=arg_defn.prepare_value(self,@ruby_style_hash[ruby_kwargs_key])
+ overwrite_argument(ruby_kwargs_key,prepared_value)
+ end
+ end
+ end
+end
# File 'lib/graphql/schema/input_object.rb', line 123
+
+defargument(*args,**kwargs,&block)
+ argument_defn=super(*args,**kwargs,&block)
+ ifone_of?
+ ifargument_defn.type.non_null?
+ raiseArgumentError,"Argument '#{argument_defn.path}' must be nullable because it is part of a OneOf type, add `required: false`."
+ end
+ ifargument_defn.default_value?
+ raiseArgumentError,"Argument '#{argument_defn.path}' cannot have a default value because it is part of a OneOf type, remove `default_value: ...`."
+ end
+ end
+ # Add a method access
+method_name=argument_defn.keyword
+ class_eval<<-RUBY,__FILE__,__LINE__
+ def #{method_name}
+ self[#{method_name.inspect}]
+ end
+ RUBY
+argument_defn
+end
# File 'lib/graphql/schema/input_object.rb', line 58
+
+defself.authorized?(obj,value,ctx)
+ # Authorize each argument (but this doesn't apply if `prepare` is implemented):
+ifvalue.respond_to?(:key?)
+ arguments(ctx).eachdo|_name,input_obj_arg|
+ ifvalue.key?(input_obj_arg.keyword)&&
+ !input_obj_arg.authorized?(obj,value[input_obj_arg.keyword],ctx)
+ returnfalse
+ end
+ end
+ end
+ # It didn't early-return false:
+true
+end
# File 'lib/graphql/schema/input_object.rb', line 226
+
+defcoerce_result(value,ctx)
+ # Allow the application to provide values as :snake_symbols, and convert them to the camelStrings
+value=value.reduce({}){|memo,(k,v)|memo[Member::BuildType.camelize(k.to_s)]=v;memo}
+
+ result={}
+
+ arguments(ctx).eachdo|input_key,input_field_defn|
+ input_value=value[input_key]
+ ifvalue.key?(input_key)
+ result[input_key]=ifinput_value.nil?
+ nil
+ else
+ input_field_defn.type.coerce_result(input_value,ctx)
+ end
+ end
+ end
+
+ result
+end
# File 'lib/graphql/schema/input_object.rb', line 72
+
+defself.one_of
+ if!one_of?
+ ifall_argument_definitions.any?{|arg|arg.type.non_null?}
+ raiseArgumentError,"`one_of` may not be used with required arguments -- add `required: false` to argument definitions to use `one_of`"
+ end
+ directive(GraphQL::Schema::Directive::OneOf)
+ end
+end
# File 'lib/graphql/schema/input_object.rb', line 150
+
+defvalidate_non_null_input(input,ctx,max_errors:nil)
+ warden=ctx.warden
+
+ ifinput.is_a?(Array)
+ returnGraphQL::Query::InputValidationResult.from_problem(INVALID_OBJECT_MESSAGE%{object:JSON.generate(input,quirks_mode:true)})
+ end
+
+ if!(input.respond_to?(:to_h)||input.respond_to?(:to_unsafe_h))
+ # We're not sure it'll act like a hash, so reject it:
+returnGraphQL::Query::InputValidationResult.from_problem(INVALID_OBJECT_MESSAGE%{object:JSON.generate(input,quirks_mode:true)})
+ end
+
+ # Inject missing required arguments
+missing_required_inputs=self.arguments(ctx).reduce({})do|m,(argument_name,argument)|
+ if!input.key?(argument_name)&&argument.type.non_null?&&warden.get_argument(self,argument_name)
+ m[argument_name]=nil
+ end
+
+ m
+ end
+
+ result=nil
+ [input,missing_required_inputs].eachdo|args_to_validate|
+ args_to_validate.eachdo|argument_name,value|
+ argument=warden.get_argument(self,argument_name)
+ # Items in the input that are unexpected
+ifargument.nil?
+ result||=Query::InputValidationResult.new
+ result.add_problem("Field is not defined on #{self.graphql_name}",[argument_name])
+ else
+ # Items in the input that are expected, but have invalid values
+argument_result=argument.type.validate_input(value,ctx)
+ result||=Query::InputValidationResult.new
+ if!argument_result.valid?
+ result.merge_result!(argument_name,argument_result)
+ end
+ end
+ end
+ end
+
+ ifone_of?
+ ifinput.size==1
+ input.eachdo|name,value|
+ ifvalue.nil?
+ result||=Query::InputValidationResult.new
+ result.add_problem("'#{graphql_name}' requires exactly one argument, but '#{name}' was `null`.")
+ end
+ end
+ else
+ result||=Query::InputValidationResult.new
+ result.add_problem("'#{graphql_name}' requires exactly one argument, but #{input.size} were provided.")
+ end
+ end
+
+ result
+end
# File 'lib/graphql/schema/input_object.rb', line 47
+
+defprepare
+ if@context
+ object=@context[:current_object]
+ # Pass this object's class with `as` so that messages are rendered correctly from inherited validators
+Schema::Validator.validate!(self.class.validators,object,@context,@ruby_style_hash,as:self.class)
+ self
+ else
+ self
+ end
+end
# File 'lib/graphql/schema/interface.rb', line 22
+
+defdefinition_methods(&block)
+ # Use an instance variable to tell whether it's been included previously or not;
+# You can't use constant detection because constants are brought into scope
+# by `include`, which has already happened at this point.
+if!defined?(@_definition_methods)
+ defn_methods_module=Module.new
+ @_definition_methods=defn_methods_module
+ const_set(:DefinitionMethods,defn_methods_module)
+ extend(self::DefinitionMethods)
+ end
+ self::DefinitionMethods.module_eval(&block)
+end
# File 'lib/graphql/schema/interface.rb', line 49
+
+defincluded(child_class)
+ if!child_class.is_a?(Class)
+ # In this case, it's been included into another interface.
+# This is how interface inheritance is implemented
+
+ # We need this before we can call `own_interfaces`
+child_class.extend(Schema::Interface::DefinitionMethods)
+
+ child_class.type_membership_class(self.type_membership_class)
+ child_class.ancestors.reverse_eachdo|ancestor|
+ ifancestor.const_defined?(:DefinitionMethods)&&ancestor!=child_class
+ child_class.extend(ancestor::DefinitionMethods)
+ end
+ end
+
+ child_class.introspection(introspection)
+ child_class.description(description)
+ # If interfaces are mixed into each other, only define this class once
+if!child_class.const_defined?(:UnresolvedTypeError,false)
+ add_unresolved_type_error(child_class)
+ end
+ elsifchild_class<GraphQL::Schema::Object
+ # This is being included into an object type, make sure it's using `implements(...)`
+backtrace_line=caller(0,10).find{|line|line.include?("schema/member/has_interfaces.rb")&&line.include?("in `implements'")}
+ if!backtrace_line
+ raise"Attach interfaces using `implements(#{self})`, not `include(#{self})`"
+ end
+ end
+
+ super
+end
+ This method is part of a private API.
+ You should avoid using this method if possible, as it may be removed or be changed in the future.
+
+
The introspection system is prepared with a bunch of LateBoundTypes.
+Replace those with the objects that they refer to, since LateBoundTypes
+aren’t handled at runtime.
You can use the result of Introspection::INTROSPECTION_QUERY
+to make a schema. This schema is missing some important details like
+resolve functions, but it does include the full type system,
+so you can use it to validate queries.
+ This method is part of a private API.
+ You should avoid using this method if possible, as it may be removed or be changed in the future.
+
+
Creates the default name for a schema member.
+The default name is the Ruby constant name,
+without any namespaces and with any -Type suffix removed
+
+
+
+
+
+
+
+
+
+
+
+
+
+102
+103
+104
+105
+106
+107
+108
+
+
+
# File 'lib/graphql/schema/member/base_dsl_methods.rb', line 102
+
+defdefault_graphql_name
+ @default_graphql_name||=begin
+ raiseGraphQL::RequiredImplementationMissingError,'Anonymous class should declare a `graphql_name`'ifname.nil?
+ g_name=-name.split("::").last
+ g_name.end_with?("Type")?g_name.sub(/Type\Z/,""):g_name
+ end
+end
+ This method is part of a private API.
+ You should avoid using this method if possible, as it may be removed or be changed in the future.
+
+
Just a convenience method to point out that people should use graphql_name instead
+
+
+
+
+
+
+
+
+
+
+
+
+
+30
+31
+32
+33
+34
+35
+36
+37
+
+
+
# File 'lib/graphql/schema/member/base_dsl_methods.rb', line 30
+
+defname(new_name=nil)
+ returnsuper()ifnew_name.nil?
+
+ fail(
+ "The new name override method is `graphql_name`, not `name`. Usage: "\
+ "graphql_name \"#{new_name}\""
+ )
+end
# File 'lib/graphql/schema/member/build_type.rb', line 140
+
+defconstantize(string)
+ names=string.split('::')
+
+ # Trigger a built-in NameError exception including the ill-formed constant in the message.
+Object.const_get(string)ifnames.empty?
+
+ # Remove the first blank element in case of '::ClassName' notation.
+names.shiftifnames.size>1&&names.first.empty?
+
+ names.inject(Object)do|constant,name|
+ ifconstant==Object
+ constant.const_get(name)
+ else
+ candidate=constant.const_get(name)
+ nextcandidateifconstant.const_defined?(name,false)
+ nextcandidateunlessObject.const_defined?(name)
+
+ # Go down the ancestors to check if it is owned directly. The check
+# stops when we reach Object or the end of ancestors tree.
+constant=constant.ancestors.injectdo|const,ancestor|
+ breakconstifancestor==Object
+ breakancestorifancestor.const_defined?(name,false)
+ const
+ end
+
+ # Owner is in Object, so raise.
+constant.const_get(name,false)
+ end
+ end
+end
# File 'lib/graphql/schema/member/build_type.rb', line 12
+
+defparse_type(type_expr,null:)
+ list_type=false
+
+ return_type=casetype_expr
+ whenString
+ casetype_expr
+ when"String"
+ GraphQL::Types::String
+ when"Int","Integer"
+ GraphQL::Types::Int
+ when"Float"
+ GraphQL::Types::Float
+ when"Boolean"
+ GraphQL::Types::Boolean
+ when"ID"
+ GraphQL::Types::ID
+ when/\A\[.*\]\Z/
+ list_type=true
+ # List members are required by default
+parse_type(type_expr[1..-2],null:false)
+ when/.*!\Z/
+ null=false
+ parse_type(type_expr[0..-2],null:true)
+ else
+ maybe_type=constantize(type_expr)
+ casemaybe_type
+ whenModule
+ # This is a way to check that it's the right kind of module:
+ifmaybe_type.respond_to?(:kind)
+ maybe_type
+ else
+ raiseArgumentError,"Unexpected class/module found for GraphQL type: #{type_expr} (must be type definition class/module)"
+ end
+ end
+ end
+ whenGraphQL::Schema::LateBoundType
+ type_expr
+ whenArray
+ casetype_expr.length
+ when1
+ list_type=true
+ # List members are required by default
+parse_type(type_expr.first,null:false)
+ when2
+ inner_type,nullable_option=type_expr
+ ifnullable_option.keys!=[:null]||(nullable_option[:null]!=true&&nullable_option[:null]!=false)
+ raiseArgumentError,LIST_TYPE_ERROR
+ end
+ list_type=true
+ parse_type(inner_type,null:nullable_option[:null])
+ else
+ raiseArgumentError,LIST_TYPE_ERROR
+ end
+ whenGraphQL::Schema::NonNull,GraphQL::Schema::List
+ type_expr
+ whenModule
+ # This is a way to check that it's the right kind of module:
+iftype_expr.respond_to?(:kind)
+ type_expr
+ else
+ # Eg `String` => GraphQL::Types::String
+parse_type(type_expr.name,null:true)
+ end
+ whenProc
+ parse_type(type_expr.call,null:true)
+ whenfalse
+ raiseArgumentError,"Received `false` instead of a type, maybe a `!` should be replaced with `null: true` (for fields) or `required: true` (for arguments)"
+ end
+
+ ifreturn_type.nil?
+ raise"Unexpected type input: #{type_expr.inspect} (#{type_expr.class})"
+ end
+
+ # Apply list_type first, that way the
+# .to_non_null_type applies to the list type, not the inner type
+iflist_type
+ return_type=return_type.to_list_type
+ end
+
+ if!null
+ return_type=return_type.to_non_null_type
+ end
+
+
+ return_type
+end
# File 'lib/graphql/schema/member/has_arguments.rb', line 112
+
+defarguments(context=GraphQL::Query::NullContext.instance)
+ ifown_arguments.any?
+ own_arguments_that_apply={}
+ own_arguments.eachdo|name,args_entry|
+ if(visible_defn=Warden.visible_entry?(:visible_argument?,args_entry,context))
+ own_arguments_that_apply[visible_defn.graphql_name]=visible_defn
+ end
+ end
+ end
+ # might be nil if there are actually no arguments
+own_arguments_that_apply||own_arguments
+end
+ This method is part of a private API.
+ You should avoid using this method if possible, as it may be removed or be changed in the future.
+
+
Usually, this is validated statically by RequiredArgumentsArePresent,
+but not for directives.
+TODO apply static validations on schema definitions?
+
+
+
+
+
+
+
+
+
+
+
+
+
+321
+322
+323
+324
+
+
+
# File 'lib/graphql/schema/member/has_arguments.rb', line 321
+
+defvalidate_directive_argument(arg_defn,value)
+ # this is only implemented on directives.
+nil
+end
+
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/api-doc/2.1.6/GraphQL/Schema/Member/HasArguments/ArgumentClassAccessor.html b/api-doc/2.1.6/GraphQL/Schema/Member/HasArguments/ArgumentClassAccessor.html
new file mode 100644
index 0000000000..a53c2b4fa7
--- /dev/null
+++ b/api-doc/2.1.6/GraphQL/Schema/Member/HasArguments/ArgumentClassAccessor.html
@@ -0,0 +1,215 @@
+
+
+
+
+
+
+ Module: GraphQL::Schema::Member::HasArguments::ArgumentClassAccessor
+
+ — GraphQL Ruby API Documentation
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
# File 'lib/graphql/schema/member/has_arguments.rb', line 379
+
+defauthorize_application_object(argument,id,context,loaded_application_object)
+ context.query.after_lazy(loaded_application_object)do|application_object|
+ ifapplication_object.nil?
+ err=GraphQL::LoadApplicationObjectFailedError.new(context:context,argument:argument,id:id,object:application_object)
+ application_object=load_application_object_failed(err)
+ end
+ # Double-check that the located object is actually of this type
+# (Don't want to allow arbitrary access to objects this way)
+ifapplication_object.nil?
+ nil
+ else
+ maybe_lazy_resolve_type=context.schema.resolve_type(argument.loads,application_object,context)
+ context.query.after_lazy(maybe_lazy_resolve_type)do|resolve_type_result|
+ ifresolve_type_result.is_a?(Array)&&resolve_type_result.size==2
+ application_object_type,application_object=resolve_type_result
+ else
+ application_object_type=resolve_type_result
+ # application_object is already assigned
+end
+
+ if!(
+ context.warden.possible_types(argument.loads).include?(application_object_type)||
+ context.warden.loadable?(argument.loads,context)
+ )
+ err=GraphQL::LoadApplicationObjectFailedError.new(context:context,argument:argument,id:id,object:application_object)
+ application_object=load_application_object_failed(err)
+ end
+
+ ifapplication_object.nil?
+ nil
+ else
+ # This object was loaded successfully
+# and resolved to the right type,
+# now apply the `.authorized?` class method if there is one
+context.query.after_lazy(application_object_type.authorized?(application_object,context))do|authed|
+ ifauthed
+ application_object
+ else
+ err=GraphQL::UnauthorizedError.new(
+ object:application_object,
+ type:application_object_type,
+ context:context,
+ )
+ ifself.respond_to?(:unauthorized_object)
+ err.set_backtrace(caller)
+ unauthorized_object(err)
+ else
+ raiseerr
+ end
+ end
+ end
+ end
+ end
+ end
+ end
+end
+ This method is part of a private API.
+ You should avoid using this method if possible, as it may be removed or be changed in the future.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+366
+367
+368
+369
+370
+371
+372
+
+
+
# File 'lib/graphql/schema/member/has_arguments.rb', line 366
+
+defload_application_object(argument,id,context)
+ # See if any object can be found for this ID
+ifid.nil?
+ returnnil
+ end
+ object_from_id(argument.loads,id,context)
+end
+ This method is part of a private API.
+ You should avoid using this method if possible, as it may be removed or be changed in the future.
+
+
Look up the corresponding object for a provided ID.
+By default, it uses Relay-style GraphQL::Schema.object_from_id,
+override this to find objects another way.
+ This method is part of a private API.
+ You should avoid using this method if possible, as it may be removed or be changed in the future.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+327
+328
+329
+330
+331
+
+
+
# File 'lib/graphql/schema/member/has_arguments.rb', line 327
+
+defvalidate_directive_argument(arg_defn,value)
+ ifvalue.nil?&&arg_defn.type.non_null?
+ raiseArgumentError,"#{arg_defn.path} is required, but no value was given"
+ end
+end
+
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/api-doc/2.1.6/GraphQL/Schema/Member/HasAstNode.html b/api-doc/2.1.6/GraphQL/Schema/Member/HasAstNode.html
new file mode 100644
index 0000000000..8446287b20
--- /dev/null
+++ b/api-doc/2.1.6/GraphQL/Schema/Member/HasAstNode.html
@@ -0,0 +1,305 @@
+
+
+
+
+
+
+ Module: GraphQL::Schema::Member::HasAstNode
+
+ — GraphQL Ruby API Documentation
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
# File 'lib/graphql/schema/member/has_fields.rb', line 113
+
+deffields(context=GraphQL::Query::NullContext.instance)
+ warden=Warden.from_context(context)
+ # Local overrides take precedence over inherited fields
+visible_fields={}
+ forancestorinancestors
+ ifancestor.respond_to?(:own_fields)
+ ancestor.own_fields.eachdo|field_name,fields_entry|
+ # Choose the most local definition that passes `.visible?` --
+# stop checking for fields by name once one has been found.
+if!visible_fields.key?(field_name)&&(f=Warden.visible_entry?(:visible_field?,fields_entry,context,warden))
+ visible_fields[field_name]=f
+ end
+ end
+ end
+ end
+ visible_fields
+end
# File 'lib/graphql/schema/member/has_fields.rb', line 151
+
+deffields(context=GraphQL::Query::NullContext.instance)
+ # Objects need to check that the interface implementation is visible, too
+warden=Warden.from_context(context)
+ # Local overrides take precedence over inherited fields
+visible_fields={}
+ forancestorinancestors
+ ifancestor.respond_to?(:own_fields)&&visible_interface_implementation?(ancestor,context,warden)
+ ancestor.own_fields.eachdo|field_name,fields_entry|
+ # Choose the most local definition that passes `.visible?` --
+# stop checking for fields by name once one has been found.
+if!visible_fields.key?(field_name)&&(f=Warden.visible_entry?(:visible_field?,fields_entry,context,warden))
+ visible_fields[field_name]=f
+ end
+ end
+ end
+ end
+ visible_fields
+end
# File 'lib/graphql/schema/member/has_interfaces.rb', line 7
+
+defimplements(*new_interfaces,**options)
+ new_memberships=[]
+ new_interfaces.eachdo|int|
+ ifint.is_a?(Module)
+ unlessint.include?(GraphQL::Schema::Interface)
+ raise"#{int} cannot be implemented since it's not a GraphQL Interface. Use `include` for plain Ruby modules."
+ end
+
+ new_memberships<<int.type_membership_class.new(int,self,**options)
+
+ # Include the methods here,
+# `.fields` will use the inheritance chain
+# to find inherited fields
+include(int)
+
+ # If this interface has interfaces of its own, add those, too
+int.interfaces.eachdo|next_interface|
+ implements(next_interface)
+ end
+ elsifint.is_a?(String)||int.is_a?(GraphQL::Schema::LateBoundType)
+ ifoptions.any?
+ raiseArgumentError,"`implements(...)` doesn't support options with late-loaded types yet. Remove #{options} and open an issue to request this feature."
+ end
+ new_memberships<<int
+ else
+ raiseArgumentError,"Unexpected interface definition (expected module): #{int} (#{int.class})"
+ end
+ end
+
+ # Remove any String or late-bound interfaces which are being replaced
+own_interface_type_memberships.reject!{|old_i_m|
+ if!(old_i_m.respond_to?(:abstract_type)&&old_i_m.abstract_type.is_a?(Module))
+ old_int_type=old_i_m.respond_to?(:abstract_type)?old_i_m.abstract_type:old_i_m
+ old_name=Schema::Member::BuildType.to_type_name(old_int_type)
+
+ new_memberships.any?{|new_i_m|
+ new_int_type=new_i_m.respond_to?(:abstract_type)?new_i_m.abstract_type:new_i_m
+ new_name=Schema::Member::BuildType.to_type_name(new_int_type)
+
+ new_name==old_name
+ }
+ end
+ }
+ own_interface_type_memberships.concat(new_memberships)
+end
This combination of extended -> inherited -> extended means that the base class (Schema::Object) won’t have the superclass-related code in InheritedInterfaces, but child classes of Schema::Object will have it.
+ This method is part of a private API.
+ You should avoid using this method if possible, as it may be removed or be changed in the future.
+
+
This combination of extended -> inherited -> extended
+means that the base class (Schema::Object) won’t
+have the superclass-related code in InheritedInterfaces,
+but child classes of Schema::Object will have it.
+That way, we don’t need a superclass.respond_to?(...) check.
+
+
+
+
+
+
+
+
+
+
+
+
+
+67
+68
+69
+70
+
+
+
# File 'lib/graphql/schema/member/has_interfaces.rb', line 67
+
+definherited(child_class)
+ super
+ child_class.extend(InheritedInterfaces)
+end
+
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/api-doc/2.1.6/GraphQL/Schema/Member/HasInterfaces/ClassConfigured/InheritedInterfaces.html b/api-doc/2.1.6/GraphQL/Schema/Member/HasInterfaces/ClassConfigured/InheritedInterfaces.html
new file mode 100644
index 0000000000..237fe1e3ea
--- /dev/null
+++ b/api-doc/2.1.6/GraphQL/Schema/Member/HasInterfaces/ClassConfigured/InheritedInterfaces.html
@@ -0,0 +1,306 @@
+
+
+
+
+
+
+ Module: GraphQL::Schema::Member::HasInterfaces::ClassConfigured::InheritedInterfaces
+
+ — GraphQL Ruby API Documentation
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
# File 'lib/graphql/schema/member/relay_shortcuts.rb', line 24
+
+defconnection_type_class(new_connection_type_class=nil)
+ ifnew_connection_type_class
+ initialize_relay_metadata
+ @connection_type_class=new_connection_type_class
+ else
+ # Don't call `ancestor.connection_type_class`
+# because we don't want a fallback from any ancestors --
+# only apply the fallback if _no_ ancestor has a configured value!
+forancestorinself.ancestors
+ ifancestor.respond_to?(:configured_connection_type_class,true)&&(ctc=ancestor.configured_connection_type_class)
+ returnctc
+ end
+ end
+ Types::Relay::BaseConnection
+ end
+end
# File 'lib/graphql/schema/member/relay_shortcuts.rb', line 7
+
+defedge_type_class(new_edge_type_class=nil)
+ ifnew_edge_type_class
+ initialize_relay_metadata
+ @edge_type_class=new_edge_type_class
+ else
+ # Don't call `ancestor.edge_type_class`
+# because we don't want a fallback from any ancestors --
+# only apply the fallback if _no_ ancestor has a configured value!
+forancestorinself.ancestors
+ ifancestor.respond_to?(:configured_edge_type_class,true)&&(etc=ancestor.configured_edge_type_class)
+ returnetc
+ end
+ end
+ Types::Relay::BaseEdge
+ end
+end
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/api-doc/2.1.6/GraphQL/Schema/Member/Scoped.html b/api-doc/2.1.6/GraphQL/Schema/Member/Scoped.html
new file mode 100644
index 0000000000..e290dfd098
--- /dev/null
+++ b/api-doc/2.1.6/GraphQL/Schema/Member/Scoped.html
@@ -0,0 +1,414 @@
+
+
+
+
+
+
+ Module: GraphQL::Schema::Member::Scoped
+
+ — GraphQL Ruby API Documentation
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
# File 'lib/graphql/schema/member/type_system_helpers.rb', line 39
+
+defkind
+ raiseGraphQL::RequiredImplementationMissingError,"No `.kind` defined for #{self}"
+end
# File 'lib/graphql/schema/non_null.rb', line 49
+
+defcoerce_input(value,ctx)
+ # `.validate_input` above is used for variables, but this method is used for arguments
+ifvalue.nil?
+ raiseGraphQL::ExecutionError,"`null` is not a valid input for `#{to_type_signature}`, please provide a value for this argument."
+ end
+ of_type.coerce_input(value,ctx)
+end
# File 'lib/graphql/schema/non_null.rb', line 34
+
+defvalidate_input(value,ctx,max_errors:nil)
+ ifvalue.nil?
+ result=GraphQL::Query::InputValidationResult.new
+ result.add_problem("Expected value to not be null")
+ result
+ else
+ of_type.validate_input(value,ctx,max_errors:max_errors)
+ end
+end
+
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/api-doc/2.1.6/GraphQL/Schema/NullMask.html b/api-doc/2.1.6/GraphQL/Schema/NullMask.html
new file mode 100644
index 0000000000..3714cb2605
--- /dev/null
+++ b/api-doc/2.1.6/GraphQL/Schema/NullMask.html
@@ -0,0 +1,203 @@
+
+
+
+
+
+
+ Module: GraphQL::Schema::NullMask
+
+ — GraphQL Ruby API Documentation
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
Make a new instance of this type if the auth check passes,
+otherwise, raise an error.
+
+
Probably only the framework should call this method.
+
+
This might return a Execution::Lazy if the user-provided .authorized?
+hook returns some lazy value (like a Promise).
+
+
The reason that the auth check is in this wrapper method instead of new is because
+of how it might return a Promise. It would be weird if .new returned a promise;
+It would be a headache to try to maintain Promise-y state inside a GraphQL::Schema::Object
+instance. So, hopefully this wrapper method will do the job.
# File 'lib/graphql/schema/object.rb', line 59
+
+defauthorized_new(object,context)
+ maybe_lazy_auth_val=context.query.current_trace.authorized(query:context.query,type:self,object:object)do
+ begin
+ authorized?(object,context)
+ rescueGraphQL::UnauthorizedError=>err
+ context.schema.unauthorized_object(err)
+ rescueStandardError=>err
+ context.query.handle_or_reraise(err)
+ end
+ end
+
+ auth_val=ifcontext.schema.lazy?(maybe_lazy_auth_val)
+ GraphQL::Execution::Lazy.newdo
+ context.query.current_trace.authorized_lazy(query:context.query,type:self,object:object)do
+ context.schema.sync_lazy(maybe_lazy_auth_val)
+ end
+ end
+ else
+ maybe_lazy_auth_val
+ end
+
+ context.query.after_lazy(auth_val)do|is_authorized|
+ ifis_authorized
+ self.new(object,context)
+ else
+ # It failed the authorization check, so go to the schema's authorized object hook
+err=GraphQL::UnauthorizedError.new(object:object,type:self,context:context)
+ # If a new value was returned, wrap that instead of the original value
+begin
+ new_obj=context.schema.unauthorized_object(err)
+ ifnew_obj
+ self.new(new_obj,context)
+ else
+ nil
+ end
+ end
+ end
+ end
+end
Set up a type-specific invalid null error to use when this object’s non-null fields wrongly return nil.
+It should help with debugging and bug tracker integrations.
+
+
+
+
+
+
+
+
+
+
+
+
+
+112
+113
+114
+115
+116
+117
+118
+119
+120
+
+
+
# File 'lib/graphql/schema/object.rb', line 112
+
+defconst_missing(name)
+ ifname==:InvalidNullError
+ custom_err_class=GraphQL::InvalidNullError.subclass_for(self)
+ const_set(:InvalidNullError,custom_err_class)
+ custom_err_class
+ else
+ super
+ end
+end
Mutations that extend this base class get some conventions added for free:
+
+
+
An argument called clientMutationId is always added, but it’s not passed
+to the resolve method. The value is re-inserted to the response. (It’s for
+client libraries to manage optimistic updates.)
+
The returned object type always has a field called clientMutationId to support that.
+
The mutation accepts one argument called input, arguments defined in the mutation
+class are added to that input object, which is generated by the mutation.
+
+
+
These conventions were first specified by Relay Classic, but they come in handy:
+
+
+
clientMutationId supports optimistic updates and cache rollbacks on the client
+
using a single input: argument makes it easy to post whole JSON objects to the mutation
+using one GraphQL variable ($input) instead of making a separate variable for each argument.
# File 'lib/graphql/schema/relay_classic_mutation.rb', line 35
+
+defresolve_with_support(**inputs)
+ input=inputs[:input].to_kwargs
+
+ ifinput
+ # This is handled by Relay::Mutation::Resolve, a bit hacky, but here we are.
+input_kwargs=input.to_h
+ client_mutation_id=input_kwargs.delete(:client_mutation_id)
+ inputs[:input]=input_kwargs
+ end
+
+ return_value=super(**inputs)
+
+ context.query.after_lazy(return_value)do|return_hash|
+ # It might be an error
+ifreturn_hash.is_a?(Hash)
+ return_hash[:client_mutation_id]=client_mutation_id
+ end
+ return_hash
+ end
+end
+
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/api-doc/2.1.6/GraphQL/Schema/ResolveTypeWithType.html b/api-doc/2.1.6/GraphQL/Schema/ResolveTypeWithType.html
new file mode 100644
index 0000000000..0387579730
--- /dev/null
+++ b/api-doc/2.1.6/GraphQL/Schema/ResolveTypeWithType.html
@@ -0,0 +1,225 @@
+
+
+
+
+
+
+ Module: GraphQL::Schema::ResolveTypeWithType
+
+ — GraphQL Ruby API Documentation
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
# File 'lib/graphql/schema/resolver.rb', line 32
+
+definitialize(object:,context:,field:)
+ @object=object
+ @context=context
+ @field=field
+ # Since this hash is constantly rebuilt, cache it for this call
+@arguments_by_keyword={}
+ self.class.arguments(context).eachdo|name,arg|
+ @arguments_by_keyword[arg.keyword]=arg
+ end
+ @prepared_arguments=nil
+end
Add an argument to this field’s signature, but
+also add some preparation hook methods which will be used for this argument
+
+
+
+
+
+
+
+
See Also:
+
+
+
for the signature
+
+
+
+
+
+
+
+
+
+366
+367
+368
+369
+370
+
+
+
# File 'lib/graphql/schema/resolver.rb', line 366
+
+defargument(*args,**kwargs,&block)
+ # Use `from_resolver: true` to short-circuit the InputObject's own `loads:` implementation
+# so that we can support `#load_{x}` methods below.
+super(*args,from_resolver:true,**kwargs)
+end
# File 'lib/graphql/schema/resolver.rb', line 381
+
+defextensions
+ own_exts=@own_extensions
+ # Jump through some hoops to avoid creating arrays when we don't actually need them
+ifsuperclass.respond_to?(:extensions)
+ s_exts=superclass.extensions
+ ifown_exts
+ ifs_exts.any?
+ own_exts+s_exts
+ else
+ own_exts
+ end
+ else
+ s_exts
+ end
+ else
+ own_exts||EMPTY_ARRAY
+ end
+end
Call this method to get the return type of the field,
+or use it as a configuration method to assign a return type
+instead of generating one.
+TODO unify with #null
# File 'lib/graphql/schema/resolver.rb', line 58
+
+defarguments
+ @prepared_arguments||raise("Arguments have not been prepared yet, still waiting for #load_arguments to resolve. (Call `.arguments` later in the code.)")
+end
# File 'lib/graphql/schema/resolver.rb', line 122
+
+defresolve(**args)
+ raiseGraphQL::RequiredImplementationMissingError,"#{self.class.name}#resolve should execute the field's logic"
+end
# File 'lib/graphql/schema/resolver.rb', line 66
+
+defresolve_with_support(**args)
+ # First call the ready? hook which may raise
+raw_ready_val=ifargs.any?
+ ready?(**args)
+ else
+ ready?
+ end
+ context.query.after_lazy(raw_ready_val)do|ready_val|
+ ifready_val.is_a?(Array)
+ is_ready,ready_early_return=ready_val
+ ifis_ready!=false
+ raise"Unexpected result from #ready? (expected `true`, `false` or `[false, {...}]`): [#{is_ready.inspect}, #{ready_early_return.inspect}]"
+ else
+ ready_early_return
+ end
+ elsifready_val
+ # Then call each prepare hook, which may return a different value
+# for that argument, or may return a lazy object
+load_arguments_val=load_arguments(args)
+ context.query.after_lazy(load_arguments_val)do|loaded_args|
+ @prepared_arguments=loaded_args
+ Schema::Validator.validate!(self.class.validators,object,context,loaded_args,as:@field)
+ # Then call `authorized?`, which may raise or may return a lazy object
+raw_authorized_val=ifloaded_args.any?
+ authorized?(**loaded_args)
+ else
+ authorized?
+ end
+ context.query.after_lazy(raw_authorized_val)do|authorized_val|
+ # If the `authorized?` returned two values, `false, early_return`,
+# then use the early return value instead of continuing
+ifauthorized_val.is_a?(Array)
+ authorized_result,early_return=authorized_val
+ ifauthorized_result==false
+ early_return
+ else
+ raise"Unexpected result from #authorized? (expected `true`, `false` or `[false, {...}]`): [#{authorized_result.inspect}, #{early_return.inspect}]"
+ end
+ elsifauthorized_val
+ # Finally, all the hooks have passed, so resolve it
+ifloaded_args.any?
+ public_send(self.class.resolve_method,**loaded_args)
+ else
+ public_send(self.class.resolve_method)
+ end
+ else
+ raiseGraphQL::UnauthorizedFieldError.new(context:context,object:object,type:field.owner,field:field)
+ end
+ end
+ end
+ end
+ end
+end
Call this method to get the derived return type of the mutation, or use it as a configuration method to assign a return type instead of generating one.
# File 'lib/graphql/schema/resolver/has_payload_type.rb', line 49
+
+defobject_class(new_class=nil)
+ ifnew_class
+ ifdefined?(@payload_type)
+ raise"Can't configure `object_class(...)` after the payload type has already been initialized. Move this configuration higher up the class definition."
+ end
+ @object_class=new_class
+ else
+ @object_class||find_inherited_value(:object_class,GraphQL::Schema::Object)
+ end
+end
+
+
+
+
+
+
+
+
+ #payload_type(new_payload_type = nil) ⇒ Class
+
+
+
+ Also known as:
+ type_expr
+
+
+
+
+
+
+
Call this method to get the derived return type of the mutation,
+or use it as a configuration method to assign a return type
+instead of generating one.
If an argument is flagged with loads: and no object is found for it, remove this subscription (assuming that the object was deleted in the meantime, or that it became inaccessible).
# File 'lib/graphql/schema/subscription.rb', line 22
+
+definitialize(object:,context:,field:)
+ super
+ # Figure out whether this is an update or an initial subscription
+@mode=context.query.subscription_update??:update::subscribe
+end
This is called during initial subscription to get a “name” for this subscription.
+Later, when .trigger is called, this will be called again to build another “name”.
+Any subscribers with matching topic will begin the update flow.
+
+
The default implementation creates a string using the field name, subscription scope, and argument keys and values.
+In that implementation, only .trigger calls with exact matches result in updates to subscribers.
+
+
To implement a filtered stream-type subscription flow, override this method to return a string with field name and subscription scope.
+Then, implement #update to compare its arguments to the current object and return NO_UPDATE when an
+update should be filtered out.
If an argument is flagged with loads: and no object is found for it,
+remove this subscription (assuming that the object was deleted in the meantime,
+or that it became inaccessible).
+
+
+
+
+
+
+
+
+
+
+
+
+
+94
+95
+96
+97
+98
+99
+
+
+
# File 'lib/graphql/schema/subscription.rb', line 94
+
+defload_application_object_failed(err)
+ if@mode==:update
+ unsubscribe
+ end
+ super
+end
# File 'lib/graphql/schema/subscription.rb', line 50
+
+defresolve(**args)
+ # Dispatch based on `@mode`, which will raise a `NoMethodError` if we ever
+# have an unexpected `@mode`
+public_send("resolve_#{@mode}",**args)
+end
The default implementation returns the root object.
+Override it to return NO_UPDATE if you want to
+skip updates sometimes. Or override it to return a different object.
+
+
+
+
+
+
+
+
+
+
+
+
+
+87
+88
+89
+
+
+
# File 'lib/graphql/schema/subscription.rb', line 87
+
+defupdate(args={})
+ object
+end
+
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/api-doc/2.1.6/GraphQL/Schema/Timeout.html b/api-doc/2.1.6/GraphQL/Schema/Timeout.html
new file mode 100644
index 0000000000..c9104fcbcb
--- /dev/null
+++ b/api-doc/2.1.6/GraphQL/Schema/Timeout.html
@@ -0,0 +1,527 @@
+
+
+
+
+
+
+ Class: GraphQL::Schema::Timeout
+
+ — GraphQL Ruby API Documentation
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
This plugin will stop resolving new fields after max_seconds have elapsed.
+After the time has passed, any remaining fields will be nil, with errors added
+to the errors key. Any already-resolved fields will be in the data key, so
+you’ll get a partial response.
+
+
You can subclass GraphQL::Schema::Timeout and override max_seconds and/or handle_timeout
+to provide custom logic when a timeout error occurs.
+
+
Note that this will stop a query in between field resolutions, but
+it doesn’t interrupt long-running resolve functions. Be sure to use
+timeout options for external connections. For more info, see
+www.mikeperham.com/2015/05/08/timeout-rubys-most-dangerous-api/
This error is raised when a query exceeds max_seconds.
+Since it’s a child of ExecutionError,
+its message will be added to the response’s errors key.
+
+
To raise an error that will stop query resolution, use a custom block
+to take this error and raise a new one which doesn’t descend from ExecutionError,
+such as RuntimeError.
# File 'lib/graphql/schema/timeout.rb', line 71
+
+defexecute_field(query:,field:,**_rest)
+ timeout_state=query.context.namespace(@timeout).fetch(:state)
+ # If the `:state` is `false`, then `max_seconds(query)` opted out of timeout for this query.
+iftimeout_state!=false&&Process.clock_gettime(Process::CLOCK_MONOTONIC,:millisecond)>timeout_state.fetch(:timeout_at)
+ error=GraphQL::Schema::Timeout::TimeoutError.new(field)
+ # Only invoke the timeout callback for the first timeout
+if!timeout_state[:timed_out]
+ timeout_state[:timed_out]=true
+ @timeout.handle_timeout(error,query)
+ end
+
+ error
+ else
+ super
+ end
+end
+ This method is part of a private API.
+ You should avoid using this method if possible, as it may be removed or be changed in the future.
+
+
Update a type membership whose .object_type is a string or late-bound type
+so that the type membership’s .object_type is the given object_type.
+(This is used for updating the union after the schema as lazily loaded the union member.)
# File 'lib/graphql/schema/union.rb', line 55
+
+defassign_type_membership_object_type(object_type)
+ assert_valid_union_member(object_type)
+ type_memberships.each{|tm|
+ possible_type=tm.object_type
+ ifpossible_type.is_a?(String)&&(possible_type==object_type.name)
+ # This is a match of Ruby class names, not graphql names,
+# since strings are used to refer to constants.
+tm.object_type=object_type
+ elsifpossible_type.is_a?(LateBoundType)&&possible_type.graphql_name==object_type.graphql_name
+ tm.object_type=object_type
+ end
+ }
+ nil
+end
# File 'lib/graphql/schema/validator.rb', line 122
+
+defself.validate!(validators,object,context,value,as:nil)
+ # Assuming the default case is no errors, reduce allocations in that case.
+# This will be replaced with a mutable array if we actually get any errors.
+all_errors=EMPTY_ARRAY
+
+ validators.eachdo|validator|
+ validated=as||validator.validated
+ errors=validator.validate(object,context,value)
+ iferrors&&
+ (errors.is_a?(Array)&&errors!=EMPTY_ARRAY)||
+ (errors.is_a?(String))
+ ifall_errors.frozen?# It's empty
+all_errors=[]
+ end
+ interpolation_vars={validated:validated.graphql_name,value:value.inspect}
+ iferrors.is_a?(String)
+ all_errors<<(errors%interpolation_vars)
+ else
+ errors=errors.map{|e|e%interpolation_vars}
+ all_errors.concat(errors)
+ end
+ end
+ end
+
+ ifall_errors.any?
+ raiseValidationFailedError.new(errors:all_errors)
+ end
+ nil
+end
+
+ message
+
+
+ (String)
+
+
+ (defaults to: "%{validated} is reserved")
+
+
+
+
+
+
+ in
+
+
+ (Array)
+
+
+
+ —
+
The values to reject
+
+
+
+
+
+
+
+
+
+
+
+
+
+16
+17
+18
+19
+20
+21
+
+
+
# File 'lib/graphql/schema/validator/exclusion_validator.rb', line 16
+
+definitialize(message:"%{validated} is reserved",in:,**default_options)
+ # `in` is a reserved word, so work around that
+@in_list=binding.local_variable_get(:in)
+ @message=message
+ super(**default_options)
+end
+argument:word_that_doesnt_begin_with_a_vowel,String,required:true,
+ validates:{format:{without:/\A[aeiou]/}}
+
+# It's pretty hard to come up with a legitimate use case for `without:`
+
+ #initialize(in:, message: "%{validated} is not included in the list", **default_options) ⇒ InclusionValidator
+
+
+
+
+
+
+
+
Returns a new instance of InclusionValidator.
+
+
+
+
+
+
Parameters:
+
+
+
+
+ message
+
+
+ (String)
+
+
+ (defaults to: "%{validated} is not included in the list")
+
+
+
+
+
+
+ in
+
+
+ (Array)
+
+
+
+ —
+
The values to allow
+
+
+
+
+
+
+
+
+
+
+
+
+
+18
+19
+20
+21
+22
+23
+
+
+
# File 'lib/graphql/schema/validator/inclusion_validator.rb', line 18
+
+definitialize(in:,message:"%{validated} is not included in the list",**default_options)
+ # `in` is a reserved word, so work around that
+@in_list=binding.local_variable_get(:in)
+ @message=message
+ super(**default_options)
+end
+
+ #initialize(maximum: nil, too_long: "%{validated} is too long (maximum is %{count})", minimum: nil, too_short: "%{validated} is too short (minimum is %{count})", is: nil, within: nil, wrong_length: "%{validated} is the wrong length (should be %{count})", message: nil, **default_options) ⇒ LengthValidator
+
+
+
+
+
+
+
+
Returns a new instance of LengthValidator.
+
+
+
+
+
+
Parameters:
+
+
+
+
+ maximum
+
+
+ (Integer)
+
+
+ (defaults to: nil)
+
+
+
+
+
+
+ too_long
+
+
+ (String)
+
+
+ (defaults to: "%{validated} is too long (maximum is %{count})")
+
+
+ —
+
Used when maximum is exceeded or value is greater than within
# File 'lib/graphql/schema/validator/length_validator.rb', line 25
+
+definitialize(
+ maximum:nil,too_long:"%{validated} is too long (maximum is %{count})",
+ minimum:nil,too_short:"%{validated} is too short (minimum is %{count})",
+ is:nil,within:nil,wrong_length:"%{validated} is the wrong length (should be %{count})",
+ message:nil,
+ **default_options
+)
+ ifwithin&&(minimum||maximum)
+ raiseArgumentError,"`length: { ... }` may include `within:` _or_ `minimum:`/`maximum:`, but not both"
+ end
+ # Under the hood, `within` is decomposed into `minimum` and `maximum`
+@maximum=maximum||(within&&within.max)
+ @too_long=message||too_long
+ @minimum=minimum||(within&&within.min)
+ @too_short=message||too_short
+ @is=is
+ @wrong_length=message||wrong_length
+ super(**default_options)
+end
+field:find_object,Node,null:truedo
+ argument:node_id,ID,required:false
+ argument:object_type,String,required:false
+ argument:object_id,Integer,required:false
+ # either a global `node_id` or an `object_type`/`object_id` pair is required:
+validatesrequired:{one_of:[:node_id,[:object_type,:object_id]]}
+end
+
+
+
require some value for an argument, even if it’s null
+
+
+
field:update_settings,AccountSettingsdo
+ # `required: :nullable` means this argument must be given, but may be `null`
+argument:age,Integer,required::nullable
+end
An argument, or a list of arguments, that represents a valid set of inputs for this field
+
+
+
+
+
+
+ message
+
+
+ (String)
+
+
+ (defaults to: "%{validated} has the wrong arguments")
+
+
+
+
+
+
+
+
+
+
+
+
+
+40
+41
+42
+43
+44
+45
+46
+47
+48
+49
+50
+
+
+
# File 'lib/graphql/schema/validator/required_validator.rb', line 40
+
+definitialize(one_of:nil,argument:nil,message:"%{validated} has the wrong arguments",**default_options)
+ @one_of=ifone_of
+ one_of
+ elsifargument
+ [argument]
+ else
+ raiseArgumentError,"`one_of:` or `argument:` must be given in `validates required: {...}`"
+ end
+ @message=message
+ super(**default_options)
+end
+ This class is part of a private API.
+ You should avoid using this class if possible, as it may be removed or be changed in the future.
+
+
Restrict access to a GraphQL::Schema with a user-defined visible? implementations.
+
+
When validating and executing a query, all access to schema members
+should go through a warden. If you access the schema directly,
+you may show a client something that it shouldn’t be allowed to see.
+ This method is part of a private API.
+ You should avoid using this method if possible, as it may be removed or be changed in the future.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+15
+16
+17
+18
+19
+20
+
+
+
# File 'lib/graphql/schema/warden.rb', line 15
+
+defself.from_context(context)
+ context.warden||PassThruWarden
+rescueNoMethodError
+ # this might be a hash which won't respond to #warden
+PassThruWarden
+end
If provided, confirm that field has the given owner.
+
+
+
+
+
+
+
Returns:
+
+
+
+
+
+ (Boolean)
+
+
+
+
+
+
+
+
+
+
+
+
+
+254
+255
+256
+257
+258
+259
+260
+261
+262
+
+
+
# File 'lib/graphql/schema/warden.rb', line 254
+
+defvisible_field?(field_defn,_ctx=nil,owner=field_defn.owner)
+ # This field is visible in its own right
+visible?(field_defn)&&
+ # This field's return type is visible
+visible_and_reachable_type?(field_defn.type.unwrap)&&
+ # This field is either defined on this object type,
+# or the interface it's inherited from is also visible
+((field_defn.respond_to?(:owner)&&field_defn.owner==owner)||field_on_visible_interface?(field_defn,owner))
+end
+ This class is part of a private API.
+ You should avoid using this class if possible, as it may be removed or be changed in the future.
+
+
This is used when a caller provides a Hash for context.
+We want to call the schema’s hooks, but we don’t have a full-blown warden.
+The context arguments to these methods exist purely to simplify the code that
+calls methods on this object, so it will have everything it needs.
Order is important here. Some validators skip later hooks.
+which stops the visit on that node. That way it doesn’t try to find fields on types that
+don’t exist, etc.
# File 'lib/graphql/static_validation/rules/argument_literals_are_compatible_error.rb', line 21
+
+defto_h
+ if@coerce_extensions
+ extensions=@coerce_extensions
+ # This is for legacy compat -- but this key is supposed to be a GraphQL type name :confounded:
+extensions["typeName"]="CoercionError"
+ else
+ extensions={
+ "code"=>code,
+ "typeName"=>type_name
+ }
+
+ ifargument_name
+ extensions["argumentName"]=argument_name
+ end
+ end
+
+ extensions.merge!(@extensions)unless@extensions.nil?
+ super.merge({
+ "extensions"=>extensions
+ })
+end
+
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/api-doc/2.1.6/GraphQL/StaticValidation/ArgumentNamesAreUnique.html b/api-doc/2.1.6/GraphQL/StaticValidation/ArgumentNamesAreUnique.html
new file mode 100644
index 0000000000..47276b296a
--- /dev/null
+++ b/api-doc/2.1.6/GraphQL/StaticValidation/ArgumentNamesAreUnique.html
@@ -0,0 +1,319 @@
+
+
+
+
+
+
+ Module: GraphQL::StaticValidation::ArgumentNamesAreUnique
+
+ — GraphQL Ruby API Documentation
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
# File 'lib/graphql/static_validation/rules/argument_names_are_unique.rb', line 17
+
+defvalidate_arguments(node)
+ argument_defns=node.arguments
+ ifargument_defns.any?
+ args_by_name=Hash.new{|h,k|h[k]=[]}
+ argument_defns.each{|a|args_by_name[a.name]<<a}
+ args_by_name.eachdo|name,defns|
+ ifdefns.size>1
+ add_error(GraphQL::StaticValidation::ArgumentNamesAreUniqueError.new("There can be only one argument named \"#{name}\"",nodes:defns,name:name))
+ end
+ end
+ end
+end
+
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/api-doc/2.1.6/GraphQL/StaticValidation/ArgumentNamesAreUniqueError.html b/api-doc/2.1.6/GraphQL/StaticValidation/ArgumentNamesAreUniqueError.html
new file mode 100644
index 0000000000..8e2462c6a1
--- /dev/null
+++ b/api-doc/2.1.6/GraphQL/StaticValidation/ArgumentNamesAreUniqueError.html
@@ -0,0 +1,432 @@
+
+
+
+
+
+
+ Class: GraphQL::StaticValidation::ArgumentNamesAreUniqueError
+
+ — GraphQL Ruby API Documentation
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
Returns The most-recently-entered GraphQL::Argument, if currently inside one.
+
+
+
+
+
+
+
Returns:
+
+
+
+
+
+ (GraphQL::Argument, nil)
+
+
+
+ —
+
The most-recently-entered GraphQL::Argument, if currently inside one
+
+
+
+
+
+
+
+
+
+
+
+
+163
+164
+165
+166
+167
+
+
+
# File 'lib/graphql/static_validation/base_visitor.rb', line 163
+
+defargument_definition
+ # Don't get the _last_ one because that's the current one.
+# Get the second-to-last one, which is the parent of the current one.
+@argument_definitions[-2]
+end
# File 'lib/graphql/static_validation/base_visitor.rb', line 71
+
+defon_inline_fragment(node,parent)
+ on_fragment_with_type(node)do
+ @path.push("...#{node.type?" on #{node.type.to_query_string}":""}")
+ super
+ end
+end
# File 'lib/graphql/static_validation/definition_dependencies.rb', line 10
+
+definitialize(*)
+ super
+ @defdep_node_paths={}
+
+ # { name => [node, ...] } pairs for fragments (although duplicate-named fragments are _invalid_, they are _possible_)
+@defdep_fragment_definitions=Hash.new{|h,k|h[k]=[]}
+
+ # This tracks dependencies from fragment to Node where it was used
+# { fragment_definition_name => [dependent_node, dependent_node]}
+@defdep_dependent_definitions=Hash.new{|h,k|h[k]=Set.new}
+
+ # First-level usages of spreads within definitions
+# (When a key has an empty list as its value,
+# we can resolve that key's dependents)
+# { definition_node => [node, node ...] }
+@defdep_immediate_dependencies=Hash.new{|h,k|h[k]=Set.new}
+
+ # When we encounter a spread,
+# this node is the one who depends on it
+@defdep_current_parent=nil
+end
# File 'lib/graphql/static_validation/definition_dependencies.rb', line 58
+
+defon_fragment_spread(node,parent)
+ @defdep_node_paths[node]=NodeWithPath.new(node,context.path)
+
+ # Track both sides of the dependency
+@defdep_dependent_definitions[node.name]<<@defdep_current_parent
+ @defdep_immediate_dependencies[@defdep_current_parent]<<node
+ super
+end
# File 'lib/graphql/static_validation/rules/fields_have_appropriate_selections.rb', line 16
+
+defon_operation_definition(node,_parent)
+ ifvalidate_field_selections(node,type_definition)
+ super
+ end
+end
+
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/api-doc/2.1.6/GraphQL/StaticValidation/FieldsHaveAppropriateSelectionsError.html b/api-doc/2.1.6/GraphQL/StaticValidation/FieldsHaveAppropriateSelectionsError.html
new file mode 100644
index 0000000000..8f7dd21296
--- /dev/null
+++ b/api-doc/2.1.6/GraphQL/StaticValidation/FieldsHaveAppropriateSelectionsError.html
@@ -0,0 +1,504 @@
+
+
+
+
+
+
+ Class: GraphQL::StaticValidation::FieldsHaveAppropriateSelectionsError
+
+ — GraphQL Ruby API Documentation
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
Validates that a selection set is valid if all fields (including spreading any
+fragments) either correspond to distinct response names or can be merged
+without ambiguity.
+
+
Original Algorithm: https://github.com/graphql/graphql-js/blob/master/src/validation/rules/OverlappingFieldsCanBeMerged.js
# File 'lib/graphql/static_validation/rules/fragment_names_are_unique.rb', line 16
+
+defon_document(_n,_p)
+ super
+ @fragments_by_name.eachdo|name,fragments|
+ iffragments.length>1
+ add_error(GraphQL::StaticValidation::FragmentNamesAreUniqueError.new(
+ %|Fragment name "#{name}" must be unique|,
+ nodes:fragments,
+ name:name
+ ))
+ end
+ end
+end
# File 'lib/graphql/static_validation/rules/fragment_spreads_are_possible.rb', line 25
+
+defon_document(node,parent)
+ super
+ @spreads_to_validate.eachdo|frag_spread|
+ frag_node=context.fragments[frag_spread.node.name]
+ iffrag_node
+ fragment_child_name=frag_node.type.name
+ fragment_child=context.warden.get_type(fragment_child_name)
+ # Might be non-existent type name
+iffragment_child
+ validate_fragment_in_scope(frag_spread.parent_type,fragment_child,frag_spread.node,context,frag_spread.path)
+ end
+ end
+ end
+end
# File 'lib/graphql/static_validation/rules/fragment_types_exist.rb', line 5
+
+defon_fragment_definition(node,_parent)
+ ifvalidate_type_exists(node)
+ super
+ end
+end
# File 'lib/graphql/static_validation/rules/fragment_types_exist.rb', line 11
+
+defon_inline_fragment(node,_parent)
+ ifvalidate_type_exists(node)
+ super
+ end
+end
+
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/api-doc/2.1.6/GraphQL/StaticValidation/FragmentTypesExistError.html b/api-doc/2.1.6/GraphQL/StaticValidation/FragmentTypesExistError.html
new file mode 100644
index 0000000000..56a227f129
--- /dev/null
+++ b/api-doc/2.1.6/GraphQL/StaticValidation/FragmentTypesExistError.html
@@ -0,0 +1,432 @@
+
+
+
+
+
+
+ Class: GraphQL::StaticValidation::FragmentTypesExistError
+
+ — GraphQL Ruby API Documentation
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
# File 'lib/graphql/static_validation/rules/mutation_root_exists.rb', line 5
+
+defon_operation_definition(node,_parent)
+ ifnode.operation_type=='mutation'&&context.warden.root_type_for_operation("mutation").nil?
+ add_error(GraphQL::StaticValidation::MutationRootExistsError.new(
+ 'Schema is not configured for mutations',
+ nodes:node
+ ))
+ else
+ super
+ end
+end
+
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/api-doc/2.1.6/GraphQL/StaticValidation/MutationRootExistsError.html b/api-doc/2.1.6/GraphQL/StaticValidation/MutationRootExistsError.html
new file mode 100644
index 0000000000..0da2a8d767
--- /dev/null
+++ b/api-doc/2.1.6/GraphQL/StaticValidation/MutationRootExistsError.html
@@ -0,0 +1,348 @@
+
+
+
+
+
+
+ Class: GraphQL::StaticValidation::MutationRootExistsError
+
+ — GraphQL Ruby API Documentation
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
# File 'lib/graphql/static_validation/rules/operation_names_are_valid.rb', line 15
+
+defon_document(node,parent)
+ super
+ op_count=@operation_names.values.inject(0){|m,v|m+v.size}
+
+ @operation_names.eachdo|name,nodes|
+ ifname.nil?&&op_count>1
+ add_error(GraphQL::StaticValidation::OperationNamesAreValidError.new(
+ %|Operation name is required when multiple operations are present|,
+ nodes:nodes
+ ))
+ elsifnodes.length>1
+ add_error(GraphQL::StaticValidation::OperationNamesAreValidError.new(
+ %|Operation name "#{name}" must be unique|,
+ nodes:nodes,
+ name:name
+ ))
+ end
+ end
+end
# File 'lib/graphql/static_validation/rules/query_root_exists.rb', line 5
+
+defon_operation_definition(node,_parent)
+ if(node.operation_type=='query'||node.operation_type.nil?)&&context.warden.root_type_for_operation("query").nil?
+ add_error(GraphQL::StaticValidation::QueryRootExistsError.new(
+ 'Schema is not configured for queries',
+ nodes:node
+ ))
+ else
+ super
+ end
+end
+
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/api-doc/2.1.6/GraphQL/StaticValidation/QueryRootExistsError.html b/api-doc/2.1.6/GraphQL/StaticValidation/QueryRootExistsError.html
new file mode 100644
index 0000000000..5290a29db5
--- /dev/null
+++ b/api-doc/2.1.6/GraphQL/StaticValidation/QueryRootExistsError.html
@@ -0,0 +1,348 @@
+
+
+
+
+
+
+ Class: GraphQL::StaticValidation::QueryRootExistsError
+
+ — GraphQL Ruby API Documentation
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
# File 'lib/graphql/static_validation/rules/subscription_root_exists.rb', line 5
+
+defon_operation_definition(node,_parent)
+ ifnode.operation_type=="subscription"&&context.warden.root_type_for_operation("subscription").nil?
+ add_error(GraphQL::StaticValidation::SubscriptionRootExistsError.new(
+ 'Schema is not configured for subscriptions',
+ nodes:node
+ ))
+ else
+ super
+ end
+end
+
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/api-doc/2.1.6/GraphQL/StaticValidation/SubscriptionRootExistsError.html b/api-doc/2.1.6/GraphQL/StaticValidation/SubscriptionRootExistsError.html
new file mode 100644
index 0000000000..d3e2f8be11
--- /dev/null
+++ b/api-doc/2.1.6/GraphQL/StaticValidation/SubscriptionRootExistsError.html
@@ -0,0 +1,348 @@
+
+
+
+
+
+
+ Class: GraphQL::StaticValidation::SubscriptionRootExistsError
+
+ — GraphQL Ruby API Documentation
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
# File 'lib/graphql/static_validation/validator.rb', line 29
+
+defvalidate(query,validate:true,timeout:nil,max_errors:nil)
+ query.current_trace.validate(validate:validate,query:query)do
+ errors=ifvalidate==false
+ []
+ else
+ rules_to_use=validate?@rules:[]
+ visitor_class=BaseVisitor.including_rules(rules_to_use)
+
+ context=GraphQL::StaticValidation::ValidationContext.new(query,visitor_class,max_errors)
+
+ begin
+ # CAUTION: Usage of the timeout module makes the assumption that validation rules are stateless Ruby code that requires no cleanup if process was interrupted. This means no blocking IO calls, native gems, locks, or `rescue` clauses that must be reached.
+# A timeout value of 0 or nil will execute the block without any timeout.
+Timeout::timeout(timeout)do
+ catch(:too_many_validation_errors)do
+ context.visitor.visit
+ end
+ end
+ rescueTimeout::Error
+ handle_timeout(query,context)
+ end
+
+ context.errors
+ end
+
+ {
+ errors:errors,
+ }
+ end
+rescueGraphQL::ExecutionError=>e
+ {
+ errors:[e],
+ }
+end
+
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/api-doc/2.1.6/GraphQL/StaticValidation/VariableDefaultValuesAreCorrectlyTyped.html b/api-doc/2.1.6/GraphQL/StaticValidation/VariableDefaultValuesAreCorrectlyTyped.html
new file mode 100644
index 0000000000..2f3bf64538
--- /dev/null
+++ b/api-doc/2.1.6/GraphQL/StaticValidation/VariableDefaultValuesAreCorrectlyTyped.html
@@ -0,0 +1,247 @@
+
+
+
+
+
+
+ Module: GraphQL::StaticValidation::VariableDefaultValuesAreCorrectlyTyped
+
+ — GraphQL Ruby API Documentation
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
# File 'lib/graphql/static_validation/rules/variable_names_are_unique.rb', line 5
+
+defon_operation_definition(node,parent)
+ var_defns=node.variables
+ ifvar_defns.any?
+ vars_by_name=Hash.new{|h,k|h[k]=[]}
+ var_defns.each{|v|vars_by_name[v.name]<<v}
+ vars_by_name.eachdo|name,defns|
+ ifdefns.size>1
+ add_error(GraphQL::StaticValidation::VariableNamesAreUniqueError.new(
+ "There can only be one variable named \"#{name}\"",
+ nodes:defns,
+ name:name
+ ))
+ end
+ end
+ end
+ super
+end
+
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/api-doc/2.1.6/GraphQL/StaticValidation/VariableNamesAreUniqueError.html b/api-doc/2.1.6/GraphQL/StaticValidation/VariableNamesAreUniqueError.html
new file mode 100644
index 0000000000..1a0d5c0935
--- /dev/null
+++ b/api-doc/2.1.6/GraphQL/StaticValidation/VariableNamesAreUniqueError.html
@@ -0,0 +1,432 @@
+
+
+
+
+
+
+ Class: GraphQL::StaticValidation::VariableNamesAreUniqueError
+
+ — GraphQL Ruby API Documentation
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
The problem is
+ - Variable $usage must be determined at the OperationDefinition level
+ - You can’t tell how fragments use variables until you visit FragmentDefinitions (which may be at the end of the document)
+
+
So, this validator includes some crazy logic to follow fragment spreads recursively, while avoiding infinite loops.
+
+
graphql-js solves this problem by:
+ - re-visiting the AST for each validator
+ - allowing validators to say followSpreads: true
# File 'lib/graphql/static_validation/rules/variables_are_used_and_defined.rb', line 48
+
+defon_fragment_definition(node,parent)
+ # initialize the hash of vars for this context:
+@variable_usages_for_context[node]
+ @variable_context_stack.push(node)
+ super
+ @variable_context_stack.pop
+end
# File 'lib/graphql/static_validation/rules/variables_are_used_and_defined.rb', line 33
+
+defon_operation_definition(node,parent)
+ # initialize the hash of vars for this context:
+@variable_usages_for_context[node]
+ @variable_context_stack.push(node)
+ # mark variables as defined:
+var_hash=@variable_usages_for_context[node]
+ node.variables.each{|var|
+ var_usage=var_hash[var.name]
+ var_usage.declared_by=node
+ var_usage.path=context.path
+ }
+ super
+ @variable_context_stack.pop
+end
# File 'lib/graphql/subscriptions.rb', line 161
+
+defexecute(subscription_id,event,object)
+ res=execute_update(subscription_id,event,object)
+ if!res.nil?
+ deliver(subscription_id,res)
+
+ ifres.context.namespace(:subscriptions)[:unsubscribed]
+ # `unsubscribe` was called, clean up on our side
+# The transport should also send `{more: false}` to client
+delete_subscription(subscription_id)
+ end
+ end
+
+end
# File 'lib/graphql/subscriptions.rb', line 107
+
+defexecute_update(subscription_id,event,object)
+ # Lookup the saved data for this subscription
+query_data=read_subscription(subscription_id)
+ ifquery_data.nil?
+ delete_subscription(subscription_id)
+ returnnil
+ end
+
+ # Fetch the required keys from the saved data
+query_string=query_data.fetch(:query_string)
+ variables=query_data.fetch(:variables)
+ context=query_data.fetch(:context)
+ operation_name=query_data.fetch(:operation_name)
+ execute_options={
+ query:query_string,
+ context:context,
+ subscription_topic:event.topic,
+ operation_name:operation_name,
+ variables:variables,
+ root_value:object,
+ }
+
+ # merge event's and query's context together
+context.merge!(event.context)unlessevent.context.nil?||context.nil?
+
+ execute_options[:validate]=validate_update?(**execute_options)
+ result=@schema.execute(**execute_options)
+ subscriptions_context=result.context.namespace(:subscriptions)
+ ifsubscriptions_context[:no_update]
+ result=nil
+ end
+
+ ifsubscriptions_context[:unsubscribed]&&!subscriptions_context[:final_update]
+ # `unsubscribe` was called, clean up on our side
+# The transport should also send `{more: false}` to client
+delete_subscription(subscription_id)
+ result=nil
+ end
+
+ result
+end
# File 'lib/graphql/subscriptions.rb', line 63
+
+deftrigger(event_name,args,object,scope:nil,context:{})
+ # Make something as context-like as possible, even though there isn't a current query:
+dummy_query=GraphQL::Query.new(@schema,"{ __typename }",validate:false,context:context)
+ context=dummy_query.context
+ event_name=event_name.to_s
+
+ # Try with the verbatim input first:
+field=@schema.get_field(@schema.subscription,event_name,context)
+
+ iffield.nil?
+ # And if it wasn't found, normalize it:
+normalized_event_name=normalize_name(event_name)
+ field=@schema.get_field(@schema.subscription,normalized_event_name,context)
+ iffield.nil?
+ raiseInvalidTriggerError,"No subscription matching trigger: #{event_name} (looked for #{@schema.subscription.graphql_name}.#{normalized_event_name})"
+ end
+ else
+ # Since we found a field, the original input was already normalized
+normalized_event_name=event_name
+ end
+
+ # Normalize symbol-keyed args to strings, try camelizing them
+# Should this accept a real context somehow?
+normalized_args=normalize_arguments(normalized_event_name,field,args,GraphQL::Query::NullContext.instance)
+
+ event=Subscriptions::Event.new(
+ name:normalized_event_name,
+ arguments:normalized_args,
+ field:field,
+ scope:scope,
+ context:context,
+ )
+ execute_all(event,object)
+end
Avoid the async ActionCable adapter and use the redis or PostgreSQL adapters instead. Otherwise calling #trigger won’t work from background jobs or the Rails console.
Returns a new instance of ActionCableSubscriptions.
+
+
+
+
+
+
Parameters:
+
+
+
+
+ serializer
+
+
+ (<#dump(obj), #load(string)] Used for serializing messages before handing them to `.broadcast(msg)`)
+
+
+ (defaults to: Serialize)
+
+
+ —
+
erializer [<#dump(obj), #load(string)] Used for serializing messages before handing them to .broadcast(msg)
# File 'lib/graphql/subscriptions/action_cable_subscriptions.rb', line 90
+
+definitialize(serializer:Serialize,namespace:'',action_cable:ActionCable,action_cable_coder:ActiveSupport::JSON,**rest)
+ # A per-process map of subscriptions to deliver.
+# This is provided by Rails, so let's use it
+@subscriptions=Concurrent::Map.new
+ @events=Concurrent::Map.newdo|h,k|
+ h.compute_if_absent(k)do
+ Concurrent::Map.newdo|h2,k2|
+ h2.compute_if_absent(k2){Concurrent::Array.new}
+ end
+ end
+ end
+ @action_cable=action_cable
+ @action_cable_coder=action_cable_coder
+ @serializer=serializer
+ @serialize_with_context=case@serializer.method(:load).arity
+ when1
+ false
+ when2
+ true
+ else
+ raiseArgumentError,"#{@serializer} must repond to `.load` accepting one or two arguments"
+ end
+ @transmit_ns=namespace
+ super
+end
# File 'lib/graphql/subscriptions/action_cable_subscriptions.rb', line 224
+
+defdelete_subscription(subscription_id)
+ query=@subscriptions.delete(subscription_id)
+ # In case this came from the server, tell the client to unsubscribe:
+@action_cable.server.broadcast(stream_subscription_name(subscription_id),{more:false})
+ # This can be `nil` when `.trigger` happens inside an unsubscribed ActionCable channel,
+# see https://github.com/rmosolgo/graphql-ruby/issues/2478
+ifquery
+ events=query.context.namespace(:subscriptions)[:events]
+ events.eachdo|event|
+ ev_by_fingerprint=@events[event.topic]
+ ev_for_fingerprint=ev_by_fingerprint[event.fingerprint]
+ ev_for_fingerprint.delete(event)
+ ifev_for_fingerprint.empty?
+ ev_by_fingerprint.delete(event.fingerprint)
+ end
+ end
+ end
+end
# File 'lib/graphql/subscriptions/action_cable_subscriptions.rb', line 206
+
+defread_subscription(subscription_id)
+ query=@subscriptions[subscription_id]
+ ifquery.nil?
+ # This can happen when a subscription is triggered from an unsubscribed channel,
+# see https://github.com/rmosolgo/graphql-ruby/issues/2478.
+# (This `nil` is handled by `#execute_update`)
+nil
+ else
+ {
+ query_string:query.query_string,
+ variables:query.provided_variables,
+ context:query.context.to_h,
+ operation_name:query.operation_name,
+ }
+ end
+end
Every subscribing channel is listening here, but only one of them takes any action.
+This is so we can reuse payloads when possible, and make one payload to send to
+all subscribers.
+
+
But the problem is, any channel could close at any time, so each channel has to
+be ready to take over the primary position.
+
+
To make sure there’s always one-and-only-one channel building payloads,
+let the listener belonging to the first event on the list be
+the one to build and publish payloads.
# File 'lib/graphql/subscriptions/action_cable_subscriptions.rb', line 167
+
+defsetup_stream(channel,initial_event)
+ topic=initial_event.topic
+ channel.stream_from(stream_event_name(initial_event),coder:@action_cable_coder)do|message|
+ events_by_fingerprint=@events[topic]
+ object=nil
+ events_by_fingerprint.eachdo|_fingerprint,events|
+ ifevents.any?&&events.first==initial_event
+ # The fingerprint has told us that this response should be shared by all subscribers,
+# so just run it once, then deliver the result to every subscriber
+first_event=events.first
+ first_subscription_id=first_event.context.fetch(:subscription_id)
+ object||=load_action_cable_message(message,first_event.context)
+ result=execute_update(first_subscription_id,first_event,object)
+ if!result.nil?
+ # Having calculated the result _once_, send the same payload to all subscribers
+events.eachdo|event|
+ subscription_id=event.context.fetch(:subscription_id)
+ deliver(subscription_id,result)
+ end
+ end
+ end
+ end
+ nil
+ end
+end
A query was run where these events were subscribed to.
+Store them in memory in this ActionCable frontend.
+It will receive notifications when events come in
+and re-evaluate the query locally.
# File 'lib/graphql/subscriptions/action_cable_subscriptions.rb', line 136
+
+defwrite_subscription(query,events)
+ unless(channel=query.context[:channel])
+ raiseGraphQL::Error,"This GraphQL Subscription client does not support the transport protocol expected"\
+ "by the backend Subscription Server implementation (graphql-ruby ActionCableSubscriptions in this case)."\
+ "Some official client implementation including Apollo (https://graphql-ruby.org/javascript_client/apollo_subscriptions.html), "\
+ "Relay Modern (https://graphql-ruby.org/javascript_client/relay_subscriptions.html#actioncable)."\
+ "GraphiQL via `graphiql-rails` may not work out of box (#1051)."
+ end
+ subscription_id=query.context[:subscription_id]||=build_id
+ stream=stream_subscription_name(subscription_id)
+ channel.stream_from(stream)
+ @subscriptions[subscription_id]=query
+ events.eachdo|event|
+ # Setup a new listener to run all events with this topic in this process
+setup_stream(channel,event)
+ # Add this event to the list of events to be updated
+@events[event.topic][event.fingerprint]<<event
+ end
+end
+
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/api-doc/2.1.6/GraphQL/Subscriptions/BroadcastAnalyzer.html b/api-doc/2.1.6/GraphQL/Subscriptions/BroadcastAnalyzer.html
new file mode 100644
index 0000000000..7e8b9dc1b4
--- /dev/null
+++ b/api-doc/2.1.6/GraphQL/Subscriptions/BroadcastAnalyzer.html
@@ -0,0 +1,508 @@
+
+
+
+
+
+
+ Class: GraphQL::Subscriptions::BroadcastAnalyzer
+
+ — GraphQL Ruby API Documentation
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ This method is part of a private API.
+ You should avoid using this method if possible, as it may be removed or be changed in the future.
+
+
Returns a new instance of BroadcastAnalyzer.
+
+
+
+
+
+
+
+
+
+
+
+
+
+13
+14
+15
+16
+17
+18
+
+
+
# File 'lib/graphql/subscriptions/broadcast_analyzer.rb', line 13
+
+definitialize(subject)
+ super
+ @default_broadcastable=subject.schema.subscriptions.default_broadcastable
+ # Maybe this will get set to false while analyzing
+@subscription_broadcastable=true
+end
+
+
+
+
+
+
+
+
+
+
Instance Method Details
+
+
+
+
+
+ #analyze? ⇒ Boolean
+
+
+
+
+
+
+
+
+ This method is part of a private API.
+ You should avoid using this method if possible, as it may be removed or be changed in the future.
+
+
Only analyze subscription operations
+
+
+
+
+
+
+
Returns:
+
+
+
+
+
+ (Boolean)
+
+
+
+
+
+
+
+
+
+
+
+
+
+21
+22
+23
+
+
+
# File 'lib/graphql/subscriptions/broadcast_analyzer.rb', line 21
+
+defanalyze?
+ @query.subscription?
+end
# File 'lib/graphql/subscriptions/broadcast_analyzer.rb', line 25
+
+defon_enter_field(node,parent,visitor)
+ if(@subscription_broadcastable==false)||visitor.skipping?
+ return
+ end
+
+ current_field=visitor.field_definition
+ apply_broadcastable(current_field)
+
+ current_type=visitor.parent_type_definition
+ ifcurrent_type.kind.interface?
+ pt=@query.possible_types(current_type)
+ pt.eachdo|object_type|
+ ot_field=@query.get_field(object_type,current_field.graphql_name)
+ # Inherited fields would be exactly the same object;
+# only check fields that are overrides of the inherited one
+ifot_field&&ot_field!=current_field
+ apply_broadcastable(ot_field)
+ end
+ end
+ end
+end
+
+
+
+
+
+
+
+
+ #result ⇒ void
+
+
+
+
+
+
+
+
+ This method is part of a private API.
+ You should avoid using this method if possible, as it may be removed or be changed in the future.
+
+
This method returns an undefined value.
Assign the result to context.
+(This method is allowed to return an error, but we don’t need to)
# File 'lib/graphql/subscriptions/default_subscription_resolve_extension.rb', line 20
+
+defafter_resolve(value:,context:,object:,arguments:,**rest)
+ ifvalue.is_a?(GraphQL::ExecutionError)
+ value
+ elsif(events=context.namespace(:subscriptions)[:events])
+ # This is the first execution, so gather an Event
+# for the backend to register:
+event=Subscriptions::Event.new(
+ name:field.name,
+ arguments:arguments_without_field_extras(arguments:arguments),
+ context:context,
+ field:field,
+ )
+ events<<event
+ value
+ elsifcontext.query.subscription_topic==Subscriptions::Event.serialize(
+ field.name,
+ arguments_without_field_extras(arguments:arguments),
+ field,
+ scope:(field.subscription_scope?context[field.subscription_scope]:nil),
+ )
+ # This is a subscription update. The resolver returned `skip` if it should be skipped,
+# or else it returned an object to resolve the update.
+value
+ else
+ # This is a subscription update, but this event wasn't triggered.
+context.skip
+ end
+end
# File 'lib/graphql/subscriptions/event.rb', line 47
+
+deffingerprint
+ @fingerprint||=begin
+ # When this query has been flagged as broadcastable,
+# use a generalized, stable fingerprint so that
+# duplicate subscriptions can be evaluated and distributed in bulk.
+# (`@topic` includes field, args, and subscription scope already.)
+if@context.namespace(:subscriptions)[:subscription_broadcastable]
+ "#{@topic}/#{@context.query.fingerprint}"
+ else
+ # not broadcastable, build a unique ID for this event
+@context.schema.subscriptions.build_id
+ end
+ end
+end
+
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/api-doc/2.1.6/GraphQL/Subscriptions/Instrumentation.html b/api-doc/2.1.6/GraphQL/Subscriptions/Instrumentation.html
new file mode 100644
index 0000000000..205c71f89f
--- /dev/null
+++ b/api-doc/2.1.6/GraphQL/Subscriptions/Instrumentation.html
@@ -0,0 +1,355 @@
+
+
+
+
+
+
+ Class: GraphQL::Subscriptions::Instrumentation
+
+ — GraphQL Ruby API Documentation
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
Wrap the root fields of the subscription type with special logic for:
+- Registering the subscription during the first execution
+- Evaluating the triggered portion(s) of the subscription during later execution
Raised when either:
+- An initial subscription didn’t have a value for context[subscription_scope]
+- Or, an update didn’t pass .trigger(..., scope:)
+When raised, the initial subscription or update fails completely.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/api-doc/2.1.6/GraphQL/Tracing.html b/api-doc/2.1.6/GraphQL/Tracing.html
new file mode 100644
index 0000000000..89103e96e2
--- /dev/null
+++ b/api-doc/2.1.6/GraphQL/Tracing.html
@@ -0,0 +1,135 @@
+
+
+
+
+
+
+ Module: GraphQL::Tracing
+
+ — GraphQL Ruby API Documentation
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
During auto-instrumentation this version of AppOpticsTracing is compared with the version provided in the appoptics_apm gem, so that the newer version of the class can be used.
During auto-instrumentation this version of AppOpticsTracing is compared
+with the version provided in the appoptics_apm gem, so that the newer
+version of the class can be used
+
+
+
+
+
+
+
+
+
+
+
+
+
+27
+28
+29
+
+
+
# File 'lib/graphql/tracing/appoptics_trace.rb', line 27
+
+defself.version
+ Gem::Version.new('1.0.0')
+end
+
+
+
+
+
+
+
+
+
Instance Method Details
+
+
+
+
+
+ #authorized(**data) ⇒ Object
+
+
+
+
+
+
+
+
+
+
+
+88
+89
+90
+91
+92
+93
+94
+95
+96
+97
+
+
+
# File 'lib/graphql/tracing/appoptics_trace.rb', line 88
+
+defauthorized(**data)
+ returnsuperif!defined?(AppOpticsAPM)||gql_config[:enabled]==false
+ layer=@platform_key_cache[AppOpticsTrace].platform_authorized_key_cache[data[:type]]
+ kvs=metadata(data,layer)
+
+ ::AppOpticsAPM::SDK.trace(layer,kvs)do
+ kvs.clear# we don't have to send them twice
+super
+ end
+end
# File 'lib/graphql/tracing/appoptics_trace.rb', line 99
+
+defauthorized_lazy(**data)
+ returnsuperif!defined?(AppOpticsAPM)||gql_config[:enabled]==false
+ layer=@platform_key_cache[AppOpticsTrace].platform_authorized_key_cache[data[:type]]
+ kvs=metadata(data,layer)
+
+ ::AppOpticsAPM::SDK.trace(layer,kvs)do
+ kvs.clear# we don't have to send them twice
+super
+ end
+end
# File 'lib/graphql/tracing/appoptics_trace.rb', line 110
+
+defresolve_type(**data)
+ returnsuperif!defined?(AppOpticsAPM)||gql_config[:enabled]==false
+ layer=@platform_key_cache[AppOpticsTrace].platform_resolve_type_key_cache[data[:type]]
+
+ kvs=metadata(data,layer)
+
+ ::AppOpticsAPM::SDK.trace(layer,kvs)do
+ kvs.clear# we don't have to send them twice
+super
+ end
+end
# File 'lib/graphql/tracing/appoptics_trace.rb', line 122
+
+defresolve_type_lazy(**data)
+ returnsuperif!defined?(AppOpticsAPM)||gql_config[:enabled]==false
+ layer=@platform_key_cache[AppOpticsTrace].platform_resolve_type_key_cache[data[:type]]
+ kvs=metadata(data,layer)
+
+ ::AppOpticsAPM::SDK.trace(layer,kvs)do
+ kvs.clear# we don't have to send them twice
+super
+ end
+end
+
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/api-doc/2.1.6/GraphQL/Tracing/AppOpticsTracing.html b/api-doc/2.1.6/GraphQL/Tracing/AppOpticsTracing.html
new file mode 100644
index 0000000000..5dadd708b8
--- /dev/null
+++ b/api-doc/2.1.6/GraphQL/Tracing/AppOpticsTracing.html
@@ -0,0 +1,533 @@
+
+
+
+
+
+
+ Class: GraphQL::Tracing::AppOpticsTracing
+
+ — GraphQL Ruby API Documentation
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
During auto-instrumentation this version of AppOpticsTracing is compared with the version provided in the appoptics_apm gem, so that the newer version of the class can be used.
During auto-instrumentation this version of AppOpticsTracing is compared
+with the version provided in the appoptics_apm gem, so that the newer
+version of the class can be used
+
+
+
+
+
+
+
+
+
+
+
+
+
+27
+28
+29
+
+
+
# File 'lib/graphql/tracing/appoptics_tracing.rb', line 27
+
+defself.version
+ Gem::Version.new('1.0.0')
+end
If true, the GraphQL operation name will be used as the transaction name.
+This is not advised if you run more than one query per HTTP request, for example, with graphql-client or multiplexing.
+It can also be specified per-query with context[:set_appsignal_action_name].
+
+
+
+
+
+
+
+
+
+
+
+
+
+11
+12
+13
+14
+
+
+
# File 'lib/graphql/tracing/appsignal_trace.rb', line 11
+
+definitialize(set_action_name:false,**rest)
+ @set_action_name=set_action_name
+ super
+end
If true, the GraphQL operation name will be used as the transaction name.
+This is not advised if you run more than one query per HTTP request, for example, with graphql-client or multiplexing.
+It can also be specified per-query with context[:set_appsignal_action_name].
+
+
+
+
+
+
+
+
+
+
+
+
+
+20
+21
+22
+23
+
+
+
# File 'lib/graphql/tracing/appsignal_tracing.rb', line 20
+
+definitialize(options={})
+ @set_action_name=options.fetch(:set_action_name,false)
+ super
+end
This trace class calls legacy-style tracer with payload hashes.
+New-style trace_with modules significantly reduce the overhead of tracing,
+but that advantage is lost when legacy-style tracers are also used (since the payload hashes are still constructed).
# File 'lib/graphql/tracing/data_dog_tracing.rb', line 77
+
+defanalytics_enabled?
+ # [Deprecated] options[:analytics_enabled] will be removed in the future
+analytics_available?&&Datadog::Contrib::Analytics.enabled?(options.fetch(:analytics_enabled,false))
+end
+
+
+
+
+
+
+
+
+ #analytics_sample_rate ⇒ Object
+
+
+
+
+
+
+
+
+
+
+
+82
+83
+84
+85
+
+
+
# File 'lib/graphql/tracing/data_dog_tracing.rb', line 82
+
+defanalytics_sample_rate
+ # [Deprecated] options[:analytics_sample_rate] will be removed in the future
+options.fetch(:analytics_sample_rate,1.0)
+end
If true, the GraphQL operation name will be used as the transaction name.
+This is not advised if you run more than one query per HTTP request, for example, with graphql-client or multiplexing.
+It can also be specified per-query with context[:set_new_relic_transaction_name].
+
+
+
+
+
+
+
+
+
+
+
+
+
+11
+12
+13
+14
+
+
+
# File 'lib/graphql/tracing/new_relic_trace.rb', line 11
+
+definitialize(set_transaction_name:false,**_rest)
+ @set_transaction_name=set_transaction_name
+ super
+end
If true, the GraphQL operation name will be used as the transaction name.
+This is not advised if you run more than one query per HTTP request, for example, with graphql-client or multiplexing.
+It can also be specified per-query with context[:set_new_relic_transaction_name].
+
+
+
+
+
+
+
+
+
+
+
+
+
+20
+21
+22
+23
+
+
+
# File 'lib/graphql/tracing/new_relic_tracing.rb', line 20
+
+definitialize(options={})
+ @set_transaction_name=options.fetch(:set_transaction_name,false)
+ super
+end
This implementation forwards events to a notification handler (i.e.
+ActiveSupport::Notifications or Dry::Monitor::Notifications)
+with a graphql suffix.
This implementation forwards events to a notification handler (i.e.
+ActiveSupport::Notifications or Dry::Monitor::Notifications)
+with a graphql suffix.
# File 'lib/graphql/tracing/notifications_tracing.rb', line 47
+
+deftrace(key,metadata,&blk)
+ prefixed_key=KEYS[key]||"#{key}.graphql"
+
+ # Cache the new keys while making sure not to induce a memory leak
+ifKEYS.size<MAX_KEYS_SIZE
+ KEYS[key]||=prefixed_key
+ end
+
+ @notifications_engine.instrument(prefixed_key,metadata,&blk)
+end
+
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/api-doc/2.1.6/GraphQL/Tracing/NullTracer.html b/api-doc/2.1.6/GraphQL/Tracing/NullTracer.html
new file mode 100644
index 0000000000..d34e2b9a3d
--- /dev/null
+++ b/api-doc/2.1.6/GraphQL/Tracing/NullTracer.html
@@ -0,0 +1,175 @@
+
+
+
+
+
+
+ Module: GraphQL::Tracing::NullTracer
+
+ — GraphQL Ruby API Documentation
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
If true, the GraphQL operation name will be used as the transaction name.
+This is not advised if you run more than one query per HTTP request, for example, with graphql-client or multiplexing.
+It can also be specified per-query with context[:set_scout_transaction_name].
+
+
+
+
+
+
+
+
+
+
+
+
+
+13
+14
+15
+16
+17
+
+
+
# File 'lib/graphql/tracing/scout_trace.rb', line 13
+
+definitialize(set_transaction_name:false,**_rest)
+ self.class.include(ScoutApm::Tracer)
+ @set_transaction_name=set_transaction_name
+ super
+end
+
+
+
+
+
+
+
+
+ #platform_authorized(platform_key, &block) ⇒ Object
+
+
+
+ Also known as:
+ platform_resolve_type
+
+
+
+
+
+
+
+
+
+
+53
+54
+55
+
+
+
# File 'lib/graphql/tracing/scout_trace.rb', line 53
+
+defplatform_authorized(platform_key,&block)
+ self.class.instrument("GraphQL",platform_key,INSTRUMENT_OPTS,&block)
+end
If true, the GraphQL operation name will be used as the transaction name.
+This is not advised if you run more than one query per HTTP request, for example, with graphql-client or multiplexing.
+It can also be specified per-query with context[:set_scout_transaction_name].
This is the base class for a trace instance whose methods are called during query execution.
+“Trace modes” are subclasses of this with custom tracing modules mixed in.
+
+
A trace module may implement any of the methods on Trace, being sure to call super
+to continue any tracing hooks and call the actual runtime behavior. See Backtrace::Trace for example.
[
+ SCALAR=TypeKind.new("SCALAR",input:true,leaf:true,description:'Indicates this type is a scalar.'),
+ OBJECT=TypeKind.new("OBJECT",fields:true,description:'Indicates this type is an object. `fields` and `interfaces` are valid fields.'),
+ INTERFACE=TypeKind.new("INTERFACE",abstract:true,fields:true,description:'Indicates this type is an interface. `fields` and `possibleTypes` are valid fields.'),
+ UNION=TypeKind.new("UNION",abstract:true,description:'Indicates this type is a union. `possibleTypes` is a valid field.'),
+ ENUM=TypeKind.new("ENUM",input:true,leaf:true,description:'Indicates this type is an enum. `enumValues` is a valid field.'),
+ INPUT_OBJECT=TypeKind.new("INPUT_OBJECT",input:true,description:'Indicates this type is an input object. `inputFields` is a valid field.'),
+ LIST=TypeKind.new("LIST",wraps:true,description:'Indicates this type is a list. `ofType` is a valid field.'),
+ NON_NULL=TypeKind.new("NON_NULL",wraps:true,description:'Indicates this type is a non-null. `ofType` is a valid field.'),
+]
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/api-doc/2.1.6/GraphQL/TypeKinds/TypeKind.html b/api-doc/2.1.6/GraphQL/TypeKinds/TypeKind.html
new file mode 100644
index 0000000000..14ed9d76c5
--- /dev/null
+++ b/api-doc/2.1.6/GraphQL/TypeKinds/TypeKind.html
@@ -0,0 +1,1544 @@
+
+
+
+
+
+
+ Class: GraphQL::TypeKinds::TypeKind
+
+ — GraphQL Ruby API Documentation
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
# File 'lib/graphql/types/iso_8601_date_time.rb', line 54
+
+defself.coerce_input(str_value,_ctx)
+ Time.iso8601(str_value)
+rescueArgumentError,TypeError
+ begin
+ dt=Date.iso8601(str_value).to_time
+ # For compatibility, continue accepting dates given without times
+# But without this, it would zero out given any time part of `str_value` (hours and/or minutes)
+ifdt.iso8601.start_with?(str_value)
+ dt
+ elsifstr_value.length==8&&str_value.match?(/\A\d{8}\Z/)
+ # Allow dates that are missing the "-". eg. "20220404"
+dt
+ else
+ nil
+ end
+ rescueArgumentError,TypeError
+ # Invalid input
+nil
+ end
+end
# File 'lib/graphql/types/iso_8601_date_time.rb', line 38
+
+defself.coerce_result(value,_ctx)
+ casevalue
+ whenDate
+ returnvalue.to_time.iso8601(time_precision)
+ when::String
+ returnTime.parse(value).iso8601(time_precision)
+ else
+ # Time, DateTime or compatible is given:
+returnvalue.iso8601(time_precision)
+ end
+rescueStandardError=>error
+ raiseGraphQL::Error,"An incompatible object (#{value.class}) was given to #{self}. Make sure that only Times, Dates, DateTimes, and well-formatted Strings are used with this type. (#{error.message})"
+end
+
+
+
+
+
+
+
+
+ .time_precision ⇒ Integer
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
Returns:
+
+
+
+
+
+ (Integer)
+
+
+
+
+
+
+
+
+
+
+
+
+
+27
+28
+29
+
+
+
# File 'lib/graphql/types/iso_8601_date_time.rb', line 27
+
+defself.time_precision
+ @time_precision||DEFAULT_TIME_PRECISION
+end
+
+
+
+
+
+
+
+
+ .time_precision=(value) ⇒ Object
+
+
+
+
+
+
+
+
+
+
+
+
+
+
Parameters:
+
+
+
+
+ value
+
+
+ (Integer)
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+32
+33
+34
+
+
+
# File 'lib/graphql/types/iso_8601_date_time.rb', line 32
+
+defself.time_precision=(value)
+ @time_precision=value
+end
+
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/api-doc/2.1.6/GraphQL/Types/ISO8601Duration.html b/api-doc/2.1.6/GraphQL/Types/ISO8601Duration.html
new file mode 100644
index 0000000000..3643696f23
--- /dev/null
+++ b/api-doc/2.1.6/GraphQL/Types/ISO8601Duration.html
@@ -0,0 +1,755 @@
+
+
+
+
+
+
+ Class: GraphQL::Types::ISO8601Duration
+
+ — GraphQL Ruby API Documentation
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
# File 'lib/graphql/types/iso_8601_duration.rb', line 57
+
+defself.coerce_input(value,ctx)
+ unlessdefined?(ActiveSupport::Duration)
+ raiseGraphQL::Error,"ActiveSupport >= 5.0 must be loaded to use the built-in ISO8601Duration type."
+ end
+
+ begin
+ ifvalue.is_a?(ActiveSupport::Duration)
+ value
+ elsifvalue.nil?
+ nil
+ else
+ ActiveSupport::Duration.parse(value)
+ end
+ rescueArgumentError,TypeError
+ err=GraphQL::DurationEncodingError.new(value)
+ ctx.schema.type_error(err,ctx)
+ end
+end
# File 'lib/graphql/types/iso_8601_duration.rb', line 33
+
+defself.coerce_result(value,_ctx)
+ unlessdefined?(ActiveSupport::Duration)
+ raiseGraphQL::Error,"ActiveSupport >= 5.0 must be loaded to use the built-in ISO8601Duration type."
+ end
+
+ begin
+ casevalue
+ whenActiveSupport::Duration
+ value.iso8601(precision:seconds_precision)
+ when::String
+ ActiveSupport::Duration.parse(value).iso8601(precision:seconds_precision)
+ else
+ # Try calling as ActiveSupport::Duration compatible as a fallback
+value.iso8601(precision:seconds_precision)
+ end
+ rescueStandardError=>error
+ raiseGraphQL::Error,"An incompatible object (#{value.class}) was given to #{self}. Make sure that only ActiveSupport::Durations and well-formatted Strings are used with this type. (#{error.message})"
+ end
+end
+
+
+
+
+
+
+
+
+ .seconds_precision ⇒ Integer?
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
Returns:
+
+
+
+
+
+ (Integer, nil)
+
+
+
+
+
+
+
+
+
+
+
+
+
+20
+21
+22
+23
+
+
+
# File 'lib/graphql/types/iso_8601_duration.rb', line 20
+
+defself.seconds_precision
+ # ActiveSupport::Duration precision defaults to whatever input was given
+@seconds_precision
+end
An untyped JSON scalar that maps to Ruby hashes, arrays, strings, integers, floats, booleans and nils.
+This should be used judiciously because it subverts the GraphQL type system.
This module contains some types and fields that could support Relay conventions in GraphQL.
+
+
You can use these classes out of the box if you want, but if you want to use your own
+GraphQL extensions along with the features in this code, you could also
+open up the source files and copy the relevant methods and configuration into
+your own classes.
+
+
For example, the provided object types extend Types::Relay::BaseObject,
+but you might want to:
+
+
+
Migrate the extensions from Types::Relay::BaseObject into your app’s base object
+
Copy BaseConnection, BaseEdge, etc into your app, and
+ change them to extend your base object.
+
+
+
Similarly, BaseField’s extensions could be migrated to your app
+and Node could be implemented to mix in your base interface module.
Use this to implement Relay connections, or take it as inspiration
+for Relay classes in your own app.
+
+
You may wish to copy this code into your own base class,
+so you can extend your own BaseObject instead of GraphQL::Schema::Object.
+
+
+
+
+
+
+
+
Examples:
+
+
+
Implementation a connection and edge
+
+
+
classBaseObject<GraphQL::Schema::Object;end
+
+# Given some object in your app ...
+classTypes::Post<BaseObject
+end
+
+# Make a couple of base classes:
+classTypes::BaseEdge<GraphQL::Types::Relay::BaseEdge;end
+classTypes::BaseConnection<GraphQL::Types::Relay::BaseConnection;end
+
+# Then extend them for the object in your app
+classTypes::PostEdge<Types::BaseEdge
+ node_typeTypes::Post
+end
+
+classTypes::PostConnection<Types::BaseConnection
+ edge_typeTypes::PostEdge,
+ edges_nullable:true,
+ edge_nullable:true,
+ node_nullable:true,
+ nodes_field:true
+
+ # Alternatively, you can call the class methods followed by your edge type
+# edges_nullable true
+# edge_nullable true
+# node_nullable true
+# has_nodes_field true
+# edge_type Types::PostEdge
+end
Use this as a parent class in your app, or use it as inspiration for your
+own base Edge class.
+
+
For example, you may want to extend your own BaseObject instead of the
+built-in GraphQL::Schema::Object.
+
+
+
+
+
+
+
+
Examples:
+
+
+
Making a UserEdge type
+
+
+
# Make a base class for your app
+classTypes::BaseEdge<GraphQL::Types::Relay::BaseEdge
+end
+
+# Then extend your own base class
+classTypes::UserEdge<Types::BaseEdge
+ node_type(Types::User)
+end
# File 'lib/graphql/types/relay/connection_behaviors.rb', line 168
+
+defadd_page_info_field(obj_type)
+ obj_type.field:page_info,GraphQL::Types::Relay::PageInfo,null:false,description:"Information to aid in pagination."
+end
+
+
+
+
+
+
+
+
+
Instance Method Details
+
+
+
+
+
+ #edges ⇒ Object
+
+
+
+
+
+
+
+
+
+
+
+173
+174
+175
+176
+177
+178
+179
+180
+
+
+
# File 'lib/graphql/types/relay/connection_behaviors.rb', line 173
+
+defedges
+ # Assume that whatever authorization needed to happen
+# already happened at the connection level.
+current_runtime_state=Thread.current[:__graphql_runtime_info]
+ query_runtime_state=current_runtime_state[context.query]
+ query_runtime_state.was_authorized_by_scope_items=@object.was_authorized_by_scope_items?
+ @object.edges
+end
+
+
+
+
+
+
+
+
+ #nodes ⇒ Object
+
+
+
+
+
+
+
+
+
+
+
+182
+183
+184
+185
+186
+187
+188
+189
+
+
+
# File 'lib/graphql/types/relay/connection_behaviors.rb', line 182
+
+defnodes
+ # Assume that whatever authorization needed to happen
+# already happened at the connection level.
+current_runtime_state=Thread.current[:__graphql_runtime_info]
+ query_runtime_state=current_runtime_state[context.query]
+ query_runtime_state.was_authorized_by_scope_items=@object.was_authorized_by_scope_items?
+ @object.nodes
+end
+
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/api-doc/2.1.6/GraphQL/Types/Relay/ConnectionBehaviors/ClassMethods.html b/api-doc/2.1.6/GraphQL/Types/Relay/ConnectionBehaviors/ClassMethods.html
new file mode 100644
index 0000000000..adca9f8e6c
--- /dev/null
+++ b/api-doc/2.1.6/GraphQL/Types/Relay/ConnectionBehaviors/ClassMethods.html
@@ -0,0 +1,1157 @@
+
+
+
+
+
+
+ Module: GraphQL::Types::Relay::ConnectionBehaviors::ClassMethods
+
+ — GraphQL Ruby API Documentation
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
Configure this connection to return edges and nodes based on edge_type_class.
+
+
This method will use the inputs to create:
+- edges field
+- nodes field
+- description
+
+
It’s called when you subclass this base connection, trying to use the
+class name to set defaults. You can call it again in the class definition
+to override the default (or provide a value, if the default lookup failed).
Set the default edge_nullable for this class and its child classes. (Defaults to true.)
+Use edge_nullable(false) in your base class to make non-null edge fields.
+
+
+
+
+
+
+
+
+
+
+
+
+
+126
+127
+128
+129
+130
+131
+132
+
+
+
# File 'lib/graphql/types/relay/connection_behaviors.rb', line 126
+
+defedge_nullable(new_value=nil)
+ ifnew_value.nil?
+ defined?(@edge_nullable)?@edge_nullable:superclass.edge_nullable
+ else
+ @edge_nullable=new_value
+ end
+end
Set the default edges_nullable for this class and its child classes. (Defaults to true.)
+Use edges_nullable(false) in your base class to make non-null edges fields.
+
+
+
+
+
+
+
+
+
+
+
+
+
+116
+117
+118
+119
+120
+121
+122
+
+
+
# File 'lib/graphql/types/relay/connection_behaviors.rb', line 116
+
+defedges_nullable(new_value=nil)
+ ifnew_value.nil?
+ defined?(@edges_nullable)?@edges_nullable:superclass.edges_nullable
+ else
+ @edges_nullable=new_value
+ end
+end
Set the default nodes_field for this class and its child classes. (Defaults to true.)
+Use nodes_field(false) in your base class to prevent adding of a nodes field.
+
+
+
+
+
+
+
+
+
+
+
+
+
+136
+137
+138
+139
+140
+141
+142
+
+
+
# File 'lib/graphql/types/relay/connection_behaviors.rb', line 136
+
+defhas_nodes_field(new_value=nil)
+ ifnew_value.nil?
+ defined?(@nodes_field)?@nodes_field:superclass.has_nodes_field
+ else
+ @nodes_field=new_value
+ end
+end
Set the default node_nullable for this class and its child classes. (Defaults to true.)
+Use node_nullable(false) in your base class to make non-null node and nodes fields.
+
+
+
+
+
+
+
+
+
+
+
+
+
+106
+107
+108
+109
+110
+111
+112
+
+
+
# File 'lib/graphql/types/relay/connection_behaviors.rb', line 106
+
+defnode_nullable(new_value=nil)
+ ifnew_value.nil?
+ defined?(@node_nullable)?@node_nullable:superclass.node_nullable
+ else
+ @node_nullable=new_value
+ end
+end
# File 'lib/graphql/types/relay/connection_behaviors.rb', line 99
+
+defvisible?(ctx)
+ # if this is an abstract base class, there may be no `node_type`
+node_type?node_type.visible?(ctx):super
+end
+
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/api-doc/2.1.6/GraphQL/Types/Relay/EdgeBehaviors.html b/api-doc/2.1.6/GraphQL/Types/Relay/EdgeBehaviors.html
new file mode 100644
index 0000000000..3eb15087ba
--- /dev/null
+++ b/api-doc/2.1.6/GraphQL/Types/Relay/EdgeBehaviors.html
@@ -0,0 +1,196 @@
+
+
+
+
+
+
+ Module: GraphQL::Types::Relay::EdgeBehaviors
+
+ — GraphQL Ruby API Documentation
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
Set the default node_nullable for this class and its child classes. (Defaults to true.)
+Use node_nullable(false) in your base class to make non-null node field.
+
+
+
+
+
+
+
+
+
+
+
+
+
+67
+68
+69
+70
+71
+72
+73
+
+
+
# File 'lib/graphql/types/relay/edge_behaviors.rb', line 67
+
+defnode_nullable(new_value=nil)
+ ifnew_value.nil?
+ @node_nullable!=nil?@node_nullable:superclass.node_nullable
+ else
+ @node_nullable=new_value
+ end
+end
# File 'lib/graphql/types/relay/has_nodes_field.rb', line 23
+
+deffield_block
+ Proc.new{
+ argument:ids,"[ID!]!",
+ description:"IDs of the objects."
+
+ defresolve(obj,args,ctx)
+ args[:ids].map{|id|ctx.schema.object_from_id(id,ctx)}
+ end
+
+ defresolve_field(obj,args,ctx)
+ resolve(obj,args,ctx)
+ end
+ }
+end
+
+
+
+
+
+
+
+
+ .field_options ⇒ Object
+
+
+
+
+
+
+
+
+
+
+
+13
+14
+15
+16
+17
+18
+19
+20
+21
+
+
+
# File 'lib/graphql/types/relay/has_nodes_field.rb', line 13
+
+deffield_options
+ {
+ name:"nodes",
+ type:[GraphQL::Types::Relay::Node,null:true],
+ null:false,
+ description:"Fetches a list of objects given a list of IDs.",
+ relay_nodes_field:true,
+ }
+end
+
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/api-doc/2.1.6/GraphQL/Types/Relay/Node.html b/api-doc/2.1.6/GraphQL/Types/Relay/Node.html
new file mode 100644
index 0000000000..4e688fd2b6
--- /dev/null
+++ b/api-doc/2.1.6/GraphQL/Types/Relay/Node.html
@@ -0,0 +1,294 @@
+
+
+
+
+
+
+ Module: GraphQL::Types::Relay::Node
+
+ — GraphQL Ruby API Documentation
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
# File 'lib/graphql/unauthorized_field_error.rb', line 7
+
+definitialize(message=nil,object:nil,type:nil,context:nil,field:nil)
+ ifmessage.nil?&&[field,type].any?(&:nil?)
+ raiseArgumentError,"#{self.class.name} requires either a message or keywords"
+ end
+
+ @field=field
+ message||=begin
+ ifobject
+ "An instance of #{object.class} failed #{type.name}'s authorization check on field #{field.name}"
+ else
+ "Failed #{type.name}'s authorization check on field #{field.name}"
+ end
+ end
+ super(message,object:object,type:type,context:context)
+end
+
+
+
+
+
+
+
+
+
Instance Attribute Details
+
+
+
+
+
+
+ #field ⇒ Field
+
+
+
+
+
+
+
+
Returns the field that failed the authorization check.
+
+
+
+
+
+
+
Returns:
+
+
+
+
+
+ (Field)
+
+
+
+ —
+
the field that failed the authorization check
+
+
+
+
+
+
+
+
+
+
+
+
+5
+6
+7
+
+
+
# File 'lib/graphql/unauthorized_field_error.rb', line 5
+
+deffield
+ @field
+end
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/api-doc/2.1.6/GraphQL/UnresolvedTypeError.html b/api-doc/2.1.6/GraphQL/UnresolvedTypeError.html
new file mode 100644
index 0000000000..3d558da211
--- /dev/null
+++ b/api-doc/2.1.6/GraphQL/UnresolvedTypeError.html
@@ -0,0 +1,696 @@
+
+
+
+
+
+
+ Exception: GraphQL::UnresolvedTypeError
+
+ — GraphQL Ruby API Documentation
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
# File 'lib/graphql/unresolved_type_error.rb', line 21
+
+definitialize(value,field,parent_type,resolved_type,possible_types)
+ @value=value
+ @field=field
+ @parent_type=parent_type
+ @resolved_type=resolved_type
+ @possible_types=possible_types
+ message="The value from \"#{field.graphql_name}\" on \"#{parent_type.graphql_name}\" could not be resolved to \"#{field.type.to_type_signature}\". " \
+ "(Received: `#{resolved_type.inspect}`, Expected: [#{possible_types.map(&:graphql_name).join(", ")}]) " \
+ "Make sure you have defined a `resolve_type` proc on your schema and that value `#{value.inspect}` " \
+ "gets resolved to a valid type. You may need to add your type to `orphan_types` if it implements an " \
+ "interface but isn't a return type of any other field."
+ super(message)
+end
+
+
+
+
+
+
+
+
+
Instance Attribute Details
+
+
+
+
+
+
+ #field ⇒ GraphQL::Field(readonly)
+
+
+
+
+
+
+
+
Returns The field whose value couldn’t be resolved (field.type is type which couldn’t be resolved).
+
+
+
+
+
+
+
Returns:
+
+
+
+
+
+ (GraphQL::Field)
+
+
+
+ —
+
The field whose value couldn’t be resolved (field.type is type which couldn’t be resolved)
+
+
+
+
+
+
+
+
+
+
+
+
+10
+11
+12
+
+
+
# File 'lib/graphql/unresolved_type_error.rb', line 10
+
+deffield
+ @field
+end
# File 'lib/generators/graphql/install_generator.rb', line 100
+
+defcreate_folder_structure
+ create_dir("#{options[:directory]}/types")
+ template("schema.erb",schema_file_path)
+
+ ["base_object","base_argument","base_field","base_enum","base_input_object","base_interface","base_scalar","base_union"].eachdo|base_type|
+ template("#{base_type}.erb","#{options[:directory]}/types/#{base_type}.rb")
+ end
+
+ # Note: You can't have a schema without the query type, otherwise introspection breaks
+template("query_type.erb","#{options[:directory]}/types/query_type.rb")
+ insert_root_type('query','QueryType')
+
+ invoke"graphql:install:mutation_root"unlessoptions.skip_mutation_root_type?
+
+ template("graphql_controller.erb","app/controllers/graphql_controller.rb")
+ route('post "/graphql", to: "graphql#execute"')
+
+ ifoptions[:batch]
+ gem("graphql-batch")
+ create_dir("#{options[:directory]}/loaders")
+ end
+
+ ifoptions.api?
+ say("Skipped graphiql, as this rails project is API only")
+ say(" You may wish to use GraphiQL.app for development: https://github.com/skevy/graphiql-app")
+ elsif!options[:skip_graphiql]
+ # `gem(...)` uses `gsub_file(...)` under the hood, which is a no-op for `rails destroy...` (when `behavior == :revoke`).
+# So handle that case by calling `gsub_file` with `force: true`.
+ifbehavior==:invoke&&!File.read(Rails.root.join("Gemfile")).include?("graphiql-rails")
+ gem("graphiql-rails",group::development)
+ elsifbehavior==:revoke
+ gemfile_pattern=/\n\s*gem ('|")graphiql-rails('|"), :?group(:| =>) :development/
+ gsub_fileRails.root.join("Gemfile"),gemfile_pattern,"",{force:true}
+ end
+
+ # This is a little cheat just to get cleaner shell output:
+log:route,'graphiql-rails'
+ shell.mutedo
+ # Rails 5.2 has better support for `route`?
+ifRails::VERSION::STRING>"5.2"
+ route<<-RUBY
+if Rails.env.development?
+ mount GraphiQL::Rails::Engine, at: "/graphiql", graphql_path: "/graphql"
+end
+RUBY
+else
+ route<<-RUBY
+if Rails.env.development?
+ mount GraphiQL::Rails::Engine, at: "/graphiql", graphql_path: "/graphql"
+ end
+RUBY
+end
+ end
+ end
+
+ ifoptions[:playground]
+ gem("graphql_playground-rails",group::development)
+
+ log:route,'graphql_playground-rails'
+ shell.mutedo
+ ifRails::VERSION::STRING>"5.2"
+ route<<-RUBY
+if Rails.env.development?
+ mount GraphqlPlayground::Rails::Engine, at: "/playground", graphql_path: "/graphql"
+end
+RUBY
+else
+ route<<-RUBY
+if Rails.env.development?
+ mount GraphqlPlayground::Rails::Engine, at: "/playground", graphql_path: "/graphql"
+ end
+RUBY
+end
+ end
+ end
+
+ ifoptions[:relay]
+ install_relay
+ end
+
+ ifgemfile_modified?
+ say"Gemfile has been modified, make sure you `bundle install`"
+ end
+end
+
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/api-doc/2.1.6/Graphql/Generators/InterfaceGenerator.html b/api-doc/2.1.6/Graphql/Generators/InterfaceGenerator.html
new file mode 100644
index 0000000000..96895c3724
--- /dev/null
+++ b/api-doc/2.1.6/Graphql/Generators/InterfaceGenerator.html
@@ -0,0 +1,163 @@
+
+
+
+
+
+
+ Class: Graphql::Generators::InterfaceGenerator
+
+ — GraphQL Ruby API Documentation
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
Take a type expression in any combination of GraphQL or Ruby styles and return it in a specified output style TODO: nullability / list with mode: :graphql doesn’t work.
Take a type expression in any combination of GraphQL or Ruby styles
+and return it in a specified output style
+TODO: nullability / list with mode: :graphql doesn’t work
