graphql 1.10.2 → 2.0.21

data/lib/graphql/query/arguments.rb

@@ -1,188 +0,0 @@
-# frozen_string_literal: true
-module GraphQL
-  class Query
-    # Read-only access to values, normalizing all keys to strings
-    #
-    # {Arguments} recursively wraps the input in {Arguments} instances.
-    class Arguments
-      extend Forwardable
-      include GraphQL::Dig
-
-      def self.construct_arguments_class(argument_owner)
-        argument_definitions = argument_owner.arguments
-        argument_owner.arguments_class = Class.new(self) do
-          self.argument_owner = argument_owner
-          self.argument_definitions = argument_definitions
-
-          argument_definitions.each do |_arg_name, arg_definition|
-            if arg_definition.method_access?
-              expose_as = arg_definition.expose_as.to_s.freeze
-              expose_as_underscored = GraphQL::Schema::Member::BuildType.underscore(expose_as).freeze
-              method_names = [expose_as, expose_as_underscored].uniq
-              method_names.each do |method_name|
-                # Don't define a helper method if it would override something.
-                if method_defined?(method_name)
-                  warn(
-                    "Unable to define a helper for argument with name '#{method_name}' "\
-                    "as this is a reserved name. Add `method_access: false` to stop this warning."
-                  )
-                else
-                  define_method(method_name) do
-                    # Always use `expose_as` here, since #[] doesn't accept underscored names
-                    self[expose_as]
-                  end
-                end
-              end
-            end
-          end
-        end
-      end
-
-      attr_reader :argument_values
-
-      def initialize(values, context:, defaults_used:)
-        @argument_values = values.inject({}) do |memo, (inner_key, inner_value)|
-          arg_name = inner_key.to_s
-          arg_defn = self.class.argument_definitions[arg_name] || raise("Not found #{arg_name} among #{self.class.argument_definitions.keys}")
-          arg_default_used = defaults_used.include?(arg_name)
-          arg_value = wrap_value(inner_value, arg_defn.type, context)
-          string_key = arg_defn.expose_as
-          memo[string_key] = ArgumentValue.new(string_key, arg_value, arg_defn, arg_default_used)
-          memo
-        end
-      end
-
-      # @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
-      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)
-      end
-
-      # @param key [String, Symbol] name of value to access
-      # @return [Boolean] true if the argument default was passed as the argument value to the resolver
-      def default_used?(key)
-        key_s = key.is_a?(String) ? key : key.to_s
-        @argument_values.fetch(key_s, NULL_ARGUMENT_VALUE).default_used?
-      end
-
-      # Get the hash of all values, with stringified keys
-      # @return [Hash] the stringified hash
-      def to_h
-        @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 :to_h, :keys, :values, :each, :any?
-
-      def prepare
-        self
-      end
-
-      # Access each key, value and type for the arguments in this set.
-      # @yield [argument_value] The {ArgumentValue} for each argument
-      # @yieldparam argument_value [ArgumentValue]
-      def each_value
-        @argument_values.each_value do |argument_value|
-          yield(argument_value)
-        end
-      end
-
-      class << self
-        attr_accessor :argument_definitions, :argument_owner
-      end
-
-      NoArguments = Class.new(self) do
-        self.argument_definitions = []
-      end
-
-      NO_ARGS = NoArguments.new({}, context: nil, defaults_used: Set.new)
-
-      # Convert this instance into valid Ruby keyword arguments
-      # @return [{Symbol=>Object}]
-      def to_kwargs
-        ruby_kwargs = {}
-
-        keys.each do |key|
-          ruby_kwargs[Schema::Member::BuildType.underscore(key).to_sym] = self[key]
-        end
-
-        ruby_kwargs
-      end
-
-      alias :to_hash :to_kwargs
-
-      private
-
-      class ArgumentValue
-        attr_reader :key, :value, :definition
-        attr_writer :default_used
-
-        def initialize(key, value, definition, default_used)
-          @key = key
-          @value = value
-          @definition = definition
-          @default_used = default_used
-        end
-
-        # @return [Boolean] true if the argument default was passed as the argument value to the resolver
-        def default_used?
-          @default_used
-        end
-      end
-
-      NULL_ARGUMENT_VALUE = ArgumentValue.new(nil, nil, nil, nil)
-
-      def wrap_value(value, arg_defn_type, context)
-        if value.nil?
-          nil
-        else
-          case arg_defn_type
-          when GraphQL::ListType
-            value.map { |item| wrap_value(item, arg_defn_type.of_type, context) }
-          when GraphQL::NonNullType
-            wrap_value(value, arg_defn_type.of_type, context)
-          when GraphQL::InputObjectType
-            if value.is_a?(Hash)
-              result = arg_defn_type.arguments_class.new(value, context: context, defaults_used: Set.new)
-              result.prepare
-            else
-              value
-            end
-          else
-            value
-          end
-        end
-      end
-
-      def unwrap_value(value)
-        case value
-        when Array
-          value.map { |item| unwrap_value(item) }
-        when Hash
-          value.inject({}) do |memo, (key, value)|
-            memo[key] = unwrap_value(value)
-            memo
-          end
-        when GraphQL::Query::Arguments, GraphQL::Schema::InputObject
-          value.to_h
-        else
-          value
-        end
-      end
-    end
-  end
-end

data/lib/graphql/query/arguments_cache.rb

@@ -1,25 +0,0 @@
-# frozen_string_literal: true
-# test_via: ../query.rb
-module GraphQL
-  class Query
-    module ArgumentsCache
-      # @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|
-            ast_node = irep_or_ast_node.is_a?(GraphQL::InternalRepresentation::Node) ? irep_or_ast_node.ast_node : irep_or_ast_node
-            h2[definition] = if definition.arguments.empty?
-              GraphQL::Query::Arguments::NO_ARGS
-            else
-              GraphQL::Query::LiteralInput.from_arguments(
-                ast_node.arguments,
-                definition,
-                query.variables,
-              )
-            end
-          end
-        end
-      end
-    end
-  end
-end

data/lib/graphql/query/executor.rb

@@ -1,53 +0,0 @@
-# frozen_string_literal: true
-# test_via: ../query.rb
-module GraphQL
-  class Query
-    class Executor
-      class PropagateNull < StandardError; end
-
-      # @return [GraphQL::Query] the query being executed
-      attr_reader :query
-
-      def initialize(query)
-        @query = query
-      end
-
-      # Evaluate {operation_name} on {query}.
-      # Handle {GraphQL::ExecutionError}s by putting them in the "errors" key.
-      # @return [Hash] A GraphQL response, with either a "data" key or an "errors" key
-      def result
-        execute
-      rescue GraphQL::ExecutionError => err
-        query.context.errors << err
-        {"errors" => [err.to_h]}
-      end
-
-      private
-
-      def execute
-        operation = query.selected_operation
-        return {} if operation.nil?
-
-        op_type = operation.operation_type
-        root_type = query.root_type_for_operation(op_type)
-        execution_strategy_class = query.schema.execution_strategy_for_operation(op_type)
-        execution_strategy = execution_strategy_class.new
-
-        query.context.execution_strategy = execution_strategy
-        data_result = begin
-          execution_strategy.execute(operation, root_type, query)
-        rescue PropagateNull
-          nil
-        end
-        result = { "data" => data_result }
-        error_result = query.context.errors.map(&:to_h)
-
-        if error_result.any?
-          result["errors"] = error_result
-        end
-
-        result
-      end
-    end
-  end
-end

data/lib/graphql/query/literal_input.rb

@@ -1,136 +0,0 @@
-# frozen_string_literal: true
-module GraphQL
-  class Query
-    # Turn query string values into something useful for query execution
-    class LiteralInput
-      def self.coerce(type, ast_node, variables)
-        case ast_node
-        when nil
-          nil
-        when Language::Nodes::NullValue
-          nil
-        when Language::Nodes::VariableIdentifier
-          variables[ast_node.name]
-        else
-          case type.kind.name
-          when "SCALAR"
-            # TODO smell
-            # This gets used for plain values during subscriber.trigger
-            if variables
-              type.coerce_input(ast_node, variables.context)
-            else
-              type.coerce_isolated_input(ast_node)
-            end
-          when "ENUM"
-            # TODO smell
-            # This gets used for plain values sometimes
-            v = ast_node.is_a?(GraphQL::Language::Nodes::Enum) ? ast_node.name : ast_node
-            if variables
-              type.coerce_input(v, variables.context)
-            else
-              type.coerce_isolated_input(v)
-            end
-          when "NON_NULL"
-            LiteralInput.coerce(type.of_type, ast_node, variables)
-          when "LIST"
-            if ast_node.is_a?(Array)
-              ast_node.map { |element_ast| LiteralInput.coerce(type.of_type, element_ast, variables) }
-            else
-              [LiteralInput.coerce(type.of_type, ast_node, variables)]
-            end
-          when "INPUT_OBJECT"
-            # TODO smell: handling AST vs handling plain Ruby
-            next_args = ast_node.is_a?(Hash) ? ast_node : ast_node.arguments
-            from_arguments(next_args, type, variables)
-          else
-            raise "Invariant: unexpected type to coerce to: #{type}"
-          end
-        end
-      end
-
-      def self.from_arguments(ast_arguments, argument_owner, variables)
-        context = variables ? variables.context : nil
-        values_hash = {}
-        defaults_used = Set.new
-
-        indexed_arguments = case ast_arguments
-        when Hash
-          ast_arguments
-        when Array
-          ast_arguments.each_with_object({}) { |a, memo| memo[a.name] = a }
-        else
-          raise ArgumentError, "Unexpected ast_arguments: #{ast_arguments}"
-        end
-
-        argument_defns = argument_owner.arguments
-        argument_defns.each do |arg_name, arg_defn|
-          ast_arg = indexed_arguments[arg_name]
-          # First, check the argument in the AST.
-          # If the value is a variable,
-          # only add a value if the variable is actually present.
-          # Otherwise, coerce the value in the AST, prepare the value and add it.
-          #
-          # TODO: since indexed_arguments can come from a plain Ruby hash,
-          # have to check for `false` or `nil` as hash values. This is getting smelly :S
-          if indexed_arguments.key?(arg_name)
-            arg_value = ast_arg.is_a?(GraphQL::Language::Nodes::Argument) ? ast_arg.value : ast_arg
-
-            value_is_a_variable = arg_value.is_a?(GraphQL::Language::Nodes::VariableIdentifier)
-
-            if (!value_is_a_variable || (value_is_a_variable && variables.key?(arg_value.name)))
-
-              value = coerce(arg_defn.type, arg_value, variables)
-              # Legacy `prepare` application
-              if arg_defn.is_a?(GraphQL::Argument)
-                value = arg_defn.prepare(value, context)
-              end
-
-              if value.is_a?(GraphQL::ExecutionError)
-                value.ast_node = ast_arg
-                raise value
-              end
-
-              values_hash[arg_name] = value
-            end
-          end
-
-          # Then, the definition for a default value.
-          # If the definition has a default value and
-          # a value wasn't provided from the AST,
-          # then add the default value.
-          if arg_defn.default_value? && !values_hash.key?(arg_name)
-            value = arg_defn.default_value
-            defaults_used << arg_name
-            # `context` isn't present when pre-calculating defaults
-            if context
-              if arg_defn.is_a?(GraphQL::Argument)
-                value = arg_defn.prepare(value, context)
-              end
-              if value.is_a?(GraphQL::ExecutionError)
-                value.ast_node = ast_arg
-                raise value
-              end
-            end
-            values_hash[arg_name] = value
-          end
-        end
-
-        if argument_owner.is_a?(Class) || argument_owner.is_a?(GraphQL::Schema::Field)
-          # A Schema::InputObject, Schema::GraphQL::Field, Schema::Directive, logic from Query::Arguments#to_kwargs
-          ruby_kwargs = {}
-          values_hash.each do |key, value|
-            ruby_kwargs[Schema::Member::BuildType.underscore(key).to_sym] = value
-          end
-          if argument_owner.is_a?(Class) && argument_owner < GraphQL::Schema::InputObject
-            argument_owner.new(ruby_kwargs: ruby_kwargs, context: context, defaults_used: defaults_used)
-          else
-            ruby_kwargs
-          end
-        else
-          result = argument_owner.arguments_class.new(values_hash, context: context, defaults_used: defaults_used)
-          result.prepare
-        end
-      end
-    end
-  end
-end

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

@@ -1,92 +0,0 @@
-# frozen_string_literal: true
-module GraphQL
-  class Query
-    class SerialExecution
-      class FieldResolution
-        attr_reader :irep_node, :parent_type, :target, :field, :arguments, :query
-
-        def initialize(selection, parent_type, target, query_ctx)
-          @irep_node = selection
-          @selection = selection
-          @parent_type = parent_type
-          @target = target
-          @query = query_ctx.query
-          @field = irep_node.definition
-          @field_ctx = query_ctx.spawn_child(
-            key: irep_node.name,
-            object: target,
-            irep_node: irep_node,
-          )
-          @arguments = @query.arguments_for(irep_node, @field)
-        end
-
-        def result
-          result_name = irep_node.name
-          raw_value = get_raw_value
-          if raw_value.is_a?(GraphQL::Execution::Execute::Skip)
-            {}
-          else
-            { result_name => get_finished_value(raw_value) }
-          end
-        end
-
-        # GraphQL::Batch depends on this
-        def execution_context
-          @field_ctx
-        end
-
-        private
-
-        # After getting the value from the field's resolve method,
-        # continue by "finishing" the value, eg. executing sub-fields or coercing values
-        def get_finished_value(raw_value)
-          case raw_value
-          when GraphQL::ExecutionError
-            raw_value.ast_node = @field_ctx.ast_node
-            raw_value.path = @field_ctx.path
-            @query.context.errors.push(raw_value)
-          when Array
-            list_errors = raw_value.each_with_index.select { |value, _| value.is_a?(GraphQL::ExecutionError) }
-            if list_errors.any?
-              list_errors.each do |error, index|
-                error.ast_node = @field_ctx.ast_node
-                error.path = @field_ctx.path + [index]
-                @query.context.errors.push(error)
-              end
-            end
-          end
-
-          begin
-            GraphQL::Query::SerialExecution::ValueResolution.resolve(
-              parent_type,
-              field,
-              field.type,
-              raw_value,
-              @selection,
-              @field_ctx,
-            )
-          rescue GraphQL::Query::Executor::PropagateNull
-            if field.type.kind.non_null?
-              raise
-            else
-              nil
-            end
-          end
-        end
-
-        # Get the result of:
-        # - Any middleware on this schema
-        # - The field's resolve method
-        # If the middleware chain returns a GraphQL::ExecutionError, its message
-        # is added to the "errors" key.
-        def get_raw_value
-          begin
-            @field_ctx.schema.middleware.invoke([parent_type, target, field, arguments, @field_ctx])
-          rescue GraphQL::ExecutionError => err
-            err
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,19 +0,0 @@
-# frozen_string_literal: true
-module GraphQL
-  class Query
-    class SerialExecution
-      module OperationResolution
-        def self.resolve(selection, target, query)
-          result = query.context.execution_strategy.selection_resolution.resolve(
-            query.root_value,
-            target,
-            selection,
-            query.context,
-          )
-
-          result
-        end
-      end
-    end
-  end
-end

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

@@ -1,23 +0,0 @@
-# frozen_string_literal: true
-module GraphQL
-  class Query
-    class SerialExecution
-      module SelectionResolution
-        def self.resolve(target, current_type, selection, query_ctx)
-          selection_result = {}
-
-          selection.typed_children[current_type].each do |name, subselection|
-            selection_result.merge!(query_ctx.execution_strategy.field_resolution.new(
-              subselection,
-              current_type,
-              target,
-              query_ctx
-            ).result)
-          end
-
-          selection_result
-        end
-      end
-    end
-  end
-end

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

@@ -1,87 +0,0 @@
-# frozen_string_literal: true
-module GraphQL
-  class Query
-    class SerialExecution
-      module ValueResolution
-        def self.resolve(parent_type, field_defn, field_type, value, selection, query_ctx)
-          if value.nil? || value.is_a?(GraphQL::ExecutionError)
-            if field_type.kind.non_null?
-              if value.nil?
-                type_error = GraphQL::InvalidNullError.new(parent_type, field_defn, value)
-                query_ctx.schema.type_error(type_error, query_ctx)
-              end
-              raise GraphQL::Query::Executor::PropagateNull
-            else
-              nil
-            end
-          else
-            case field_type.kind
-            when GraphQL::TypeKinds::SCALAR, GraphQL::TypeKinds::ENUM
-              field_type.coerce_result(value, query_ctx)
-            when GraphQL::TypeKinds::LIST
-              wrapped_type = field_type.of_type
-              result = []
-              i = 0
-              value.each do |inner_value|
-                inner_ctx = query_ctx.spawn_child(
-                  key: i,
-                  object: inner_value,
-                  irep_node: selection,
-                )
-
-                result << resolve(
-                  parent_type,
-                  field_defn,
-                  wrapped_type,
-                  inner_value,
-                  selection,
-                  inner_ctx,
-                )
-                i += 1
-              end
-              result
-            when GraphQL::TypeKinds::NON_NULL
-              wrapped_type = field_type.of_type
-              resolve(
-                parent_type,
-                field_defn,
-                wrapped_type,
-                value,
-                selection,
-                query_ctx,
-              )
-            when GraphQL::TypeKinds::OBJECT
-              query_ctx.execution_strategy.selection_resolution.resolve(
-                value,
-                field_type,
-                selection,
-                query_ctx
-              )
-            when GraphQL::TypeKinds::UNION, GraphQL::TypeKinds::INTERFACE
-              query = query_ctx.query
-              resolved_type = query.resolve_type(value)
-              possible_types = query.possible_types(field_type)
-
-              if !possible_types.include?(resolved_type)
-                type_error = GraphQL::UnresolvedTypeError.new(value, field_defn, parent_type, resolved_type, possible_types)
-                query.schema.type_error(type_error, query_ctx)
-                raise GraphQL::Query::Executor::PropagateNull
-              else
-                resolve(
-                  parent_type,
-                  field_defn,
-                  resolved_type,
-                  value,
-                  selection,
-                  query_ctx,
-                )
-              end
-            else
-              raise("Unknown type kind: #{field_type.kind}")
-            end
-          end
-        end
-      end
-    end
-  end
-end

data/lib/graphql/query/serial_execution.rb

@@ -1,39 +0,0 @@
-# frozen_string_literal: true
-require "graphql/query/serial_execution/value_resolution"
-require "graphql/query/serial_execution/field_resolution"
-require "graphql/query/serial_execution/operation_resolution"
-require "graphql/query/serial_execution/selection_resolution"
-
-module GraphQL
-  class Query
-    class SerialExecution
-      # This is the only required method for an Execution strategy.
-      # You could create a custom execution strategy and configure your schema to
-      # use that custom strategy instead.
-      #
-      # @param ast_operation [GraphQL::Language::Nodes::OperationDefinition] The operation definition to run
-      # @param root_type [GraphQL::ObjectType] either the query type or the mutation type
-      # @param query_object [GraphQL::Query] the query object for this execution
-      # @return [Hash] a spec-compliant GraphQL result, as a hash
-      def execute(ast_operation, root_type, query_object)
-        operation_resolution.resolve(
-          query_object.irep_selection,
-          root_type,
-          query_object
-        )
-      end
-
-      def field_resolution
-        self.class::FieldResolution
-      end
-
-      def operation_resolution
-        self.class::OperationResolution
-      end
-
-      def selection_resolution
-        self.class::SelectionResolution
-      end
-    end
-  end
-end