graphql 1.5.15 → 1.6.0

data/lib/graphql/query/arguments.rb

@@ -5,10 +5,9 @@ module GraphQL
     #
     # {Arguments} recursively wraps the input in {Arguments} instances.
     class Arguments
-      extend GraphQL::Delegate
+      extend Forwardable
 
       def initialize(values, argument_definitions:)
-        @original_values = values
         @argument_values = values.inject({}) do |memo, (inner_key, inner_value)|
           arg_defn = argument_definitions[inner_key.to_s]
 
@@ -22,24 +21,29 @@ module GraphQL
       # @param key [String, Symbol] name or index of value to access
       # @return [Object] the argument at that key
       def [](key)
-        key_s = key.is_a?(String) ? key : key.to_s
-        @argument_values.fetch(key_s, NULL_ARGUMENT_VALUE).value
+        @argument_values.fetch(key.to_s, NULL_ARGUMENT_VALUE).value
       end
 
       # @param key [String, Symbol] name of value to access
       # @return [Boolean] true if the argument was present in this field
       def key?(key)
-        key_s = key.is_a?(String) ? key : key.to_s
-        @argument_values.key?(key_s)
+        @argument_values.key?(key.to_s)
       end
 
-      # Get the original Ruby hash
-      # @return [Hash] the original values hash
+      # Get the hash of all values, with stringified keys
+      # @return [Hash] the stringified hash
       def to_h
-        @unwrapped_values ||= unwrap_value(@original_values)
+        @to_h ||= begin
+          h = {}
+          each_value do |arg_value|
+            arg_key = arg_value.definition.expose_as
+            h[arg_key] = unwrap_value(arg_value.value)
+          end
+          h
+        end
       end
 
-      def_delegators :string_key_values, :keys, :values, :each
+      def_delegators :to_h, :keys, :values, :each
 
       # Access each key, value and type for the arguments in this set.
       # @yield [argument_value] The {ArgumentValue} for each argument
@@ -101,21 +105,6 @@ module GraphQL
           value
         end
       end
-
-      def string_key_values
-        @string_key_values ||= stringify_keys(to_h)
-      end
-
-      def stringify_keys(value)
-        case value
-        when Hash
-          value.inject({}) { |memo, (k, v)| memo[k.to_s] = stringify_keys(v); memo }
-        when Array
-          value.map { |v| stringify_keys(v) }
-        else
-          value
-        end
-      end
     end
   end
 end

data/lib/graphql/query/arguments_cache.rb

@@ -5,21 +5,14 @@ module GraphQL
       # @return [Hash<InternalRepresentation::Node, GraphQL::Language::NodesDirectiveNode => Hash<GraphQL::Field, GraphQL::Directive => GraphQL::Query::Arguments>>]
       def self.build(query)
         Hash.new do |h1, irep_or_ast_node|
-          h1[irep_or_ast_node] = Hash.new do |h2, definition|
+          Hash.new do |h2, definition|
             ast_node = irep_or_ast_node.is_a?(GraphQL::InternalRepresentation::Node) ? irep_or_ast_node.ast_node : irep_or_ast_node
             ast_arguments = ast_node.arguments
-
-            h2[definition] = if ast_arguments.none?
-                definition.default_arguments
-            elsif definition.arguments.none?
-              GraphQL::Query::Arguments::NO_ARGS
-            else
-              GraphQL::Query::LiteralInput.from_arguments(
-                ast_arguments,
-                definition.arguments,
-                query.variables,
-              )
-            end
+            GraphQL::Query::LiteralInput.from_arguments(
+              ast_arguments,
+              definition.arguments,
+              query.variables,
+            )
           end
         end
       end

data/lib/graphql/query/context.rb

@@ -4,6 +4,7 @@ module GraphQL
     # Expose some query-specific info to field resolve functions.
     # It delegates `[]` to the hash that's passed to `GraphQL::Query#initialize`.
     class Context
+      extend Forwardable
       attr_reader :execution_strategy
       # `strategy` is required by GraphQL::Batch
       alias_method :strategy, :execution_strategy
@@ -41,24 +42,32 @@ module GraphQL
       def initialize(query:, values:)
         @query = query
         @schema = query.schema
-        @values = values || {}
+        @provided_values = values || {}
+        # Namespaced storage, where user-provided values are in `nil` namespace:
+        @storage = Hash.new { |h, k| h[k] = {} }
+        @storage[nil] = @provided_values
         @errors = []
         @path = []
       end
 
-      # Lookup `key` from the hash passed to {Schema#execute} as `context:`
-      def [](key)
-        @values[key]
-      end
+      def_delegators :@provided_values, :[], :[]=, :to_h, :key?, :fetch
+
+      # @!method [](key)
+      #   Lookup `key` from the hash passed to {Schema#execute} as `context:`
+
+      # @!method []=(key, value)
+      #   Reassign `key` to the hash passed to {Schema#execute} as `context:`
 
       # @return [GraphQL::Schema::Warden]
       def warden
         @warden ||= @query.warden
       end
 
-      # Reassign `key` to the hash passed to {Schema#execute} as `context:`
-      def []=(key, value)
-        @values[key] = value
+      # Get an isolated hash for `ns`. Doesn't affect user-provided storage.
+      # @param ns [Object] a usage-specific namespace identifier
+      # @return [Hash] namespaced storage
+      def namespace(ns)
+        @storage[ns]
       end
 
       def spawn(key:, selection:, parent_type:, field:)
@@ -71,8 +80,14 @@ module GraphQL
         )
       end
 
+      # Return this value to tell the runtime
+      # to exclude this field from the response altogether
+      def skip
+        GraphQL::Execution::Execute::SKIP
+      end
+
       class FieldResolutionContext
-        extend GraphQL::Delegate
+        extend Forwardable
 
         attr_reader :path, :selection, :field, :parent_type
 
@@ -84,7 +99,10 @@ module GraphQL
           @parent_type = parent_type
         end
 
-        def_delegators :@context, :[], :[]=, :spawn, :query, :schema, :warden, :errors, :execution_strategy, :strategy
+        def_delegators :@context,
+          :[], :[]=, :key?, :fetch, :to_h, :namespace,
+          :spawn, :query, :schema, :warden, :errors,
+          :execution_strategy, :strategy, :skip
 
         # @return [GraphQL::Language::Nodes::Field] The AST node for the currently-executing field
         def ast_node

data/lib/graphql/query/executor.rb

@@ -8,6 +8,7 @@ module GraphQL
       attr_reader :query
 
       def initialize(query)
+        warn("Executor is deprecated; use Schema#execute")
         @query = query
       end
 

data/lib/graphql/query/literal_input.rb

@@ -32,7 +32,7 @@ module GraphQL
       end
 
       def self.defaults_for(argument_defns)
-        if argument_defns.none? { |name, arg| arg.default_value? }
+        if argument_defns.values.none?(&:default_value?)
           GraphQL::Query::Arguments::NO_ARGS
         else
           from_arguments([], argument_defns, nil)
@@ -40,7 +40,8 @@ module GraphQL
       end
 
       def self.from_arguments(ast_arguments, argument_defns, variables)
-
+        # Variables is nil when making .defaults_for
+        context = variables ? variables.context : nil
         values_hash = {}
         indexed_arguments = ast_arguments.each_with_object({}) { |a, memo| memo[a.name] = a }
 
@@ -56,7 +57,7 @@ module GraphQL
             if (!value_is_a_variable || (value_is_a_variable && variables.key?(ast_arg.value.name)))
 
               value = coerce(arg_defn.type, ast_arg.value, variables)
-              value = arg_defn.prepare(value)
+              value = arg_defn.prepare(value, context)
 
               if value.is_a?(GraphQL::ExecutionError)
                 value.ast_node = ast_arg
@@ -72,7 +73,12 @@ module GraphQL
           # a value wasn't provided from the AST,
           # then add the default value.
           if arg_defn.default_value? && !values_hash.key?(arg_name)
-            values_hash[arg_name] = arg_defn.default_value
+            value = arg_defn.default_value
+            # `context` isn't present when pre-calculating defaults
+            if context
+              value = arg_defn.prepare(value, context)
+            end
+            values_hash[arg_name] = value
           end
         end
 

data/lib/graphql/query/null_context.rb

@@ -9,7 +9,7 @@ module GraphQL
         @query = nil
         @schema = GraphQL::Schema.new
         @warden = GraphQL::Schema::Warden.new(
-          GraphQL::Schema::NullMask,
+          GraphQL::Filter.new,
           context: self,
           schema: @schema,
         )

data/lib/graphql/query/serial_execution/field_resolution.rb

@@ -24,7 +24,11 @@ module GraphQL
         def result
           result_name = irep_node.name
           raw_value = get_raw_value
-          { result_name => get_finished_value(raw_value) }
+          if raw_value == GraphQL::Execution::Execute::SKIP
+            {}
+          else
+            { result_name => get_finished_value(raw_value) }
+          end
         end
 
         # GraphQL::Batch depends on this

data/lib/graphql/query/validation_pipeline.rb

@@ -52,6 +52,11 @@ module GraphQL
         @internal_representation
       end
 
+      def analyzers
+        ensure_has_validated
+        @query_analyzers
+      end
+
       private
 
       # If the pipeline wasn't run yet, run it.
@@ -80,13 +85,13 @@ module GraphQL
           end
 
           if @validation_errors.none?
-            query_analyzers = build_analyzers(@schema, @max_depth, @max_complexity)
-            if query_analyzers.any?
-              analysis_results = GraphQL::Analysis.analyze_query(@query, query_analyzers)
-              @analysis_errors = analysis_results
-                .flatten # accept n-dimensional array
-                .select { |r| r.is_a?(GraphQL::AnalysisError) }
-            end
+            @query_analyzers = build_analyzers(@schema, @max_depth, @max_complexity)
+            # if query_analyzers.any?
+            #   analysis_results = GraphQL::Analysis.analyze_query(@query, query_analyzers)
+            #   @analysis_errors = analysis_results
+            #     .flatten # accept n-dimensional array
+            #     .select { |r| r.is_a?(GraphQL::AnalysisError) }
+            # end
           end
         end
 

data/lib/graphql/query/variables.rb

@@ -3,7 +3,7 @@ module GraphQL
   class Query
     # Read-only access to query variables, applying default values if needed.
     class Variables
-      extend GraphQL::Delegate
+      extend Forwardable
 
       # @return [Array<GraphQL::Query::VariableValidationError>]  Any errors encountered when parsing the provided variables and literal values
       attr_reader :errors

data/lib/graphql/rake_task.rb

@@ -0,0 +1,140 @@
+# frozen_string_literal: true
+require "fileutils"
+module GraphQL
+  # A rake task for dumping a schema as IDL or JSON.
+  #
+  # By default, schemas are looked up by name as constants using `schema_name:`.
+  # You can provide a `load_schema` function to return your schema another way.
+  #
+  # `load_context:`, `only:` and `except:` are supported so that
+  # you can keep an eye on how filters affect your schema.
+  #
+  # @example Dump a Schema to .graphql + .json files
+  #   require "graphql/rake_task"
+  #   GraphQL::RakeTask.new(schema_name: "MySchema")
+  #
+  #   # $ rake graphql:schema:dump
+  #   # Schema IDL dumped to ./schema.graphql
+  #   # Schema JSON dumped to ./schema.json
+  #
+  # @example Invoking the task from Ruby
+  #   require "rake"
+  #   Rake::Task["graphql:schema:dump"].invoke
+  class RakeTask
+    include Rake::DSL
+
+    DEFAULT_OPTIONS = {
+      namespace: "graphql",
+      dependencies: nil,
+      schema_name: nil,
+      load_schema: ->(task) { Object.const_get(task.schema_name) },
+      load_context: ->(task) { {} },
+      only: nil,
+      except: nil,
+      directory: ".",
+      idl_outfile: "schema.graphql",
+      json_outfile: "schema.json",
+    }
+
+    # @return [String] Namespace for generated tasks
+    attr_writer :namespace
+
+    def rake_namespace
+      @namespace
+    end
+
+    # @return [Array<String>]
+    attr_accessor :dependencies
+
+    # @return [String] By default, used to find the schema as a constant.
+    # @see {#load_schema} for loading a schema another way
+    attr_accessor :schema_name
+
+    # @return [<#call(task)>] A proc for loading the target GraphQL schema
+    attr_accessor :load_schema
+
+    # @return [<#call(task)>] A callable for loading the query context
+    attr_accessor :load_context
+
+    # @return [<#call(member, ctx)>, nil] A filter for this task
+    attr_accessor :only
+
+    # @return [<#call(member, ctx)>, nil] A filter for this task
+    attr_accessor :except
+
+    # @return [String] target for IDL task
+    attr_accessor :idl_outfile
+
+    # @return [String] target for JSON task
+    attr_accessor :json_outfile
+
+    # @return [String] directory for IDL & JSON files
+    attr_accessor :directory
+
+    # Set the parameters of this task by passing keyword arguments
+    # or assigning attributes inside the block
+    def initialize(options = {})
+      default_dependencies = if Rake::Task.task_defined?("environment")
+        [:environment]
+      else
+        []
+      end
+
+      all_options = DEFAULT_OPTIONS
+        .merge(dependencies: default_dependencies)
+        .merge(options)
+      all_options.each do |k, v|
+        self.public_send("#{k}=", v)
+      end
+
+      if block_given?
+        yield(self)
+      end
+
+      define_task
+    end
+
+    private
+
+    # Use the provided `method_name` to generate a string from the specified schema
+    # then write it to `file`.
+    def write_outfile(method_name, file)
+      schema = @load_schema.call(self)
+      context = @load_context.call(self)
+      result = schema.public_send(method_name, only: @only, except: @except, context: context)
+      dir = File.dirname(file)
+      FileUtils.mkdir_p(dir)
+      File.write(file, result)
+    end
+
+    def idl_path
+      File.join(@directory, @idl_outfile)
+    end
+
+    def json_path
+      File.join(@directory, @json_outfile)
+    end
+
+    # Use the Rake DSL to add tasks
+    def define_task
+      namespace(@namespace) do
+        namespace("schema") do
+          desc("Dump the schema to IDL in #{idl_path}")
+          task :idl => @dependencies do
+            write_outfile(:to_definition, idl_path)
+            puts "Schema IDL dumped into #{idl_path}"
+          end
+
+          desc("Dump the schema to JSON in #{json_path}")
+          task :json => @dependencies do
+            write_outfile(:to_json, json_path)
+            puts "Schema JSON dumped into #{json_path}"
+          end
+
+          desc("Dump the schema to JSON and IDL")
+          task :dump => [:idl, :json]
+        end
+      end
+    end
+  end
+end

data/lib/graphql/relay/array_connection.rb

@@ -3,78 +3,59 @@ module GraphQL
   module Relay
     class ArrayConnection < BaseConnection
       def cursor_from_node(item)
-        idx = starting_offset + sliced_nodes.find_index(item) + 1
+        idx = (after ? index_from_cursor(after) : 0) + sliced_nodes.find_index(item) + 1
         encode(idx.to_s)
       end
 
-      def has_next_page
-        !!(first && sliced_nodes.count > limit)
-      end
+      private
+
+      def first
+        return @first if defined? @first
 
-      def has_previous_page
-        !!(last && starting_offset > 0)
+        @first = get_limited_arg(:first)
+        @first = max_page_size if @first && max_page_size && @first > max_page_size
+        @first
       end
 
-      private
+      def last
+        return @last if defined? @last
+
+        @last = get_limited_arg(:last)
+        @last = max_page_size if @last && max_page_size && @last > max_page_size
+        @last
+      end
 
       # apply first / last limit results
       def paged_nodes
         @paged_nodes ||= begin
           items = sliced_nodes
 
-          if limit
-            items.first(limit)
-          else
-            items
-          end
+          items = items.first(first) if first
+          items = items.last(last) if last
+          items = items.first(max_page_size) if max_page_size && !first && !last
+
+          items
         end
       end
 
       # Apply cursors to edges
       def sliced_nodes
-        @sliced_nodes ||= nodes[starting_offset..-1] || []
-      end
-
-      def index_from_cursor(cursor)
-        decode(cursor).to_i
-      end
-
-      def starting_offset
-        @starting_offset = if before
-          [previous_offset, 0].max
-        elsif last
-          [nodes.count - last, 0].max
-        else
-          previous_offset
-        end
-      end
-
-      def previous_offset
-        @previous_offset ||= if after
-          index_from_cursor(after)
+        @sliced_nodes ||= if before && after
+          nodes[index_from_cursor(after)..index_from_cursor(before)-1] || []
         elsif before
-          prev_page_size = [max_page_size, last].compact.min || 0
-          index_from_cursor(before) - prev_page_size - 1
+          nodes[0..index_from_cursor(before)-2] || []
+        elsif after
+          nodes[index_from_cursor(after)..-1] || []
         else
-          0
+          nodes
         end
       end
 
-      def limit
-        @limit ||= begin
-          limit_from_arguments = if first
-            first
-          else
-            if previous_offset < 0
-              previous_offset + (last ? last : 0)
-            else
-              last
-            end
-          end
-          [limit_from_arguments, max_page_size].compact.min
-        end
+      def index_from_cursor(cursor)
+        decode(cursor).to_i
       end
     end
+
     BaseConnection.register_connection_implementation(Array, ArrayConnection)
   end
 end