graphql 1.12.12 → 2.4.8

data/lib/graphql/non_null_type.rb

@@ -1,71 +0,0 @@
-# frozen_string_literal: true
-module GraphQL
-  # A non-null type modifies another type.
-  #
-  # Non-null types can be created with `!` (`InnerType!`)
-  # or {BaseType#to_non_null_type} (`InnerType.to_non_null_type`)
-  #
-  # For return types, it says that the returned value will _always_ be present.
-  #
-  # @example A field which _always_ returns an error
-  #   field :items, !ItemType
-  #   # or
-  #   field :items, ItemType.to_non_null_type
-  #
-  # (If the application fails to return a value, {InvalidNullError} will be passed to {Schema#type_error}.)
-  #
-  # For input types, it says that the incoming value _must_ be provided by the query.
-  #
-  # @example A field which _requires_ a string input
-  #   field :newNames do
-  #     # ...
-  #     argument :values, !types.String
-  #     # or
-  #     argument :values, types.String.to_non_null_type
-  #   end
-  #
-  # (If a value isn't provided, {Query::VariableValidationError} will be raised).
-  #
-  # Given a non-null type, you can always get the underlying type with {#unwrap}.
-  #
-  class NonNullType < GraphQL::BaseType
-    include GraphQL::BaseType::ModifiesAnotherType
-    extend Forwardable
-
-    attr_reader :of_type
-    def initialize(of_type:)
-      super()
-      @of_type = of_type
-    end
-
-    def valid_input?(value, ctx)
-      validate_input(value, ctx).valid?
-    end
-
-    def validate_input(value, ctx)
-      if value.nil?
-        result = GraphQL::Query::InputValidationResult.new
-        result.add_problem("Expected value to not be null")
-        result
-      else
-        of_type.validate_input(value, ctx)
-      end
-    end
-
-    def_delegators :@of_type, :coerce_input, :coerce_result, :list?
-
-    def kind
-      GraphQL::TypeKinds::NON_NULL
-    end
-
-    def to_s
-      "#{of_type.to_s}!"
-    end
-    alias_method :inspect, :to_s
-    alias :to_type_signature :to_s
-
-    def non_null?
-      true
-    end
-  end
-end

data/lib/graphql/object_type.rb

@@ -1,130 +0,0 @@
-# frozen_string_literal: true
-module GraphQL
-  # @api deprecated
-  class ObjectType < GraphQL::BaseType
-    extend Define::InstanceDefinable::DeprecatedDefine
-
-    accepts_definitions :interfaces, :fields, :mutation, :relay_node_type, field: GraphQL::Define::AssignObjectField
-    accepts_definitions implements: ->(type, *interfaces, inherit: false) { type.implements(interfaces, inherit: inherit) }
-
-    attr_accessor :fields, :mutation, :relay_node_type
-    ensure_defined(:fields, :mutation, :interfaces, :relay_node_type)
-
-    # @!attribute fields
-    #   @return [Hash<String => GraphQL::Field>] Map String fieldnames to their {GraphQL::Field} implementations
-
-    # @!attribute mutation
-    #   @return [GraphQL::Relay::Mutation, nil] The mutation this object type was derived from, if it is an auto-generated payload type.
-
-    def initialize
-      super
-      @fields = {}
-      @clean_inherited_fields = nil
-      @structural_interface_type_memberships = []
-      @inherited_interface_type_memberships = []
-    end
-
-    def initialize_copy(other)
-      super
-      @structural_interface_type_memberships = other.structural_interface_type_memberships.dup
-      @inherited_interface_type_memberships = other.inherited_interface_type_memberships.dup
-      @fields = other.fields.dup
-    end
-
-    # This method declares interfaces for this type AND inherits any field definitions
-    # @param new_interfaces [Array<GraphQL::Interface>] interfaces that this type implements
-    # @deprecated Use `implements` instead of `interfaces`.
-    def interfaces=(new_interfaces)
-      @structural_interface_type_memberships = []
-      @inherited_interface_type_memberships = []
-      @clean_inherited_fields = nil
-      implements(new_interfaces, inherit: true)
-    end
-
-    def interfaces(ctx = GraphQL::Query::NullContext)
-      ensure_defined
-      visible_ifaces = []
-      unfiltered = ctx == GraphQL::Query::NullContext
-      [@structural_interface_type_memberships, @inherited_interface_type_memberships].each do |tms|
-        tms.each do |type_membership|
-          if unfiltered || type_membership.visible?(ctx)
-            # if this is derived from a class-based object, we have to
-            # get the `.graphql_definition` of the attached interface.
-            visible_ifaces << GraphQL::BaseType.resolve_related_type(type_membership.abstract_type)
-          end
-        end
-      end
-
-      visible_ifaces
-    end
-
-    def kind
-      GraphQL::TypeKinds::OBJECT
-    end
-
-    # This fields doesnt have instrumenation applied
-    # @see [Schema#get_field] Get field with instrumentation
-    # @return [GraphQL::Field] The field definition for `field_name` (may be inherited from interfaces)
-    def get_field(field_name)
-      fields[field_name] || interface_fields[field_name]
-    end
-
-    # These fields don't have instrumenation applied
-    # @see [Schema#get_fields] Get fields with instrumentation
-    # @return [Array<GraphQL::Field>] All fields, including ones inherited from interfaces
-    def all_fields
-      interface_fields.merge(self.fields).values
-    end
-
-    # Declare that this object implements this interface.
-    # This declaration will be validated when the schema is defined.
-    # @param interfaces [Array<GraphQL::Interface>] add a new interface that this type implements
-    # @param inherits [Boolean] If true, copy the interfaces' field definitions to this type
-    def implements(interfaces, inherit: false, **options)
-      if !interfaces.is_a?(Array)
-        raise ArgumentError, "`implements(interfaces)` must be an array, not #{interfaces.class} (#{interfaces})"
-      end
-      @clean_inherited_fields = nil
-
-      type_memberships = inherit ? @inherited_interface_type_memberships : @structural_interface_type_memberships
-      interfaces.each do |iface|
-        iface = BaseType.resolve_related_type(iface)
-        if iface.is_a?(GraphQL::InterfaceType)
-          type_memberships << iface.type_membership_class.new(iface, self, **options)
-        end
-      end
-    end
-
-    def resolve_type_proc
-      nil
-    end
-
-    attr_writer :structural_interface_type_memberships
-
-    protected
-
-    attr_reader :structural_interface_type_memberships, :inherited_interface_type_memberships
-
-    private
-
-    def normalize_interfaces(ifaces)
-      ifaces.map { |i_type| GraphQL::BaseType.resolve_related_type(i_type) }
-    end
-
-    def interface_fields
-      if @clean_inherited_fields
-        @clean_inherited_fields
-      else
-        ensure_defined
-        @clean_inherited_fields = {}
-        @inherited_interface_type_memberships.each do |type_membership|
-          iface = GraphQL::BaseType.resolve_related_type(type_membership.abstract_type)
-          if iface.is_a?(GraphQL::InterfaceType)
-            @clean_inherited_fields.merge!(iface.fields)
-          end
-        end
-        @clean_inherited_fields
-      end
-    end
-  end
-end

data/lib/graphql/query/arguments.rb

@@ -1,189 +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)
-                  GraphQL::Deprecation.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
-      def_delegators :@argument_values, :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,24 +0,0 @@
-# frozen_string_literal: true
-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,52 +0,0 @@
-# frozen_string_literal: true
-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