graphql 1.9.0 → 2.1.1

data/lib/graphql/filter.rb

@@ -1,53 +0,0 @@
-# frozen_string_literal: true
-module GraphQL
-  # @api private
-  class Filter
-    def initialize(only: nil, except: nil)
-      @only = only
-      @except = except
-    end
-
-    # Returns true if `member, ctx` passes this filter
-    def call(member, ctx)
-      (@only ? @only.call(member, ctx) : true) &&
-      (@except ? !@except.call(member, ctx) : true)
-    end
-
-    def merge(only: nil, except: nil)
-      onlies = [self].concat(Array(only))
-      merged_only = MergedOnly.build(onlies)
-      merged_except = MergedExcept.build(Array(except))
-      self.class.new(only: merged_only, except: merged_except)
-    end
-
-    private
-
-    class MergedOnly
-      def initialize(first, second)
-        @first = first
-        @second = second
-      end
-
-      def call(member, ctx)
-        @first.call(member, ctx) && @second.call(member, ctx)
-      end
-
-      def self.build(onlies)
-        case onlies
-        when 0
-          nil
-        when 1
-          onlies[0]
-        else
-          onlies.reduce { |memo, only| self.new(memo, only) }
-        end
-      end
-    end
-
-    class MergedExcept < MergedOnly
-      def call(member, ctx)
-        @first.call(member, ctx) || @second.call(member, ctx)
-      end
-    end
-  end
-end

data/lib/graphql/float_type.rb

@@ -1,2 +0,0 @@
-# frozen_string_literal: true
-GraphQL::FLOAT_TYPE = GraphQL::Types::Float.graphql_definition

data/lib/graphql/function.rb

@@ -1,153 +0,0 @@
-# frozen_string_literal: true
-module GraphQL
-  # A reusable container for field logic, including arguments, resolve, return type, and documentation.
-  #
-  # Class-level values defined with the DSL will be inherited,
-  # so {GraphQL::Function}s can extend one another.
-  #
-  # It's OK to override the instance methods here in order to customize behavior of instances.
-  #
-  # @example A reusable GraphQL::Function attached as a field
-  #   class FindRecord < GraphQL::Function
-  #     attr_reader :type
-  #
-  #     def initialize(model:, type:)
-  #       @model = model
-  #       @type = type
-  #     end
-  #
-  #     argument :id, GraphQL::ID_TYPE
-  #
-  #     def call(obj, args, ctx)
-  #        @model.find(args.id)
-  #     end
-  #   end
-  #
-  #   QueryType = GraphQL::ObjectType.define do
-  #     name "Query"
-  #     field :post, function: FindRecord.new(model: Post, type: PostType)
-  #     field :comment, function: FindRecord.new(model: Comment, type: CommentType)
-  #   end
-  #
-  # @see {GraphQL::Schema::Resolver} for a replacement for `GraphQL::Function`
-  class Function
-    # @return [Hash<String => GraphQL::Argument>] Arguments, keyed by name
-    def arguments
-      self.class.arguments
-    end
-
-    # @return [GraphQL::BaseType] Return type
-    def type
-      self.class.type
-    end
-
-    # @return [Object] This function's resolver
-    def call(obj, args, ctx)
-      raise NotImplementedError
-    end
-
-    # @return [String, nil]
-    def description
-      self.class.description
-    end
-
-    # @return [String, nil]
-    def deprecation_reason
-      self.class.deprecation_reason
-    end
-
-    # @return [Integer, Proc]
-    def complexity
-      self.class.complexity || 1
-    end
-
-    class << self
-      # Define an argument for this function & its subclasses
-      # @see {GraphQL::Field} same arguments as the `argument` definition helper
-      # @return [void]
-      def argument(*args, **kwargs, &block)
-        argument = GraphQL::Argument.from_dsl(*args, **kwargs, &block)
-        own_arguments[argument.name] = argument
-        nil
-      end
-
-      # @return [Hash<String => GraphQL::Argument>] Arguments for this function class, including inherited arguments
-      def arguments
-        if parent_function?
-          own_arguments.merge(superclass.arguments)
-        else
-          own_arguments.dup
-        end
-      end
-
-      # Provides shorthand access to GraphQL's built-in types
-      def types
-        GraphQL::Define::TypeDefiner.instance
-      end
-
-      # Get or set the return type for this function class & descendants
-      # @return [GraphQL::BaseType]
-      def type(premade_type = nil, &block)
-        if block_given?
-          @type = GraphQL::ObjectType.define(&block)
-        elsif premade_type
-          @type = premade_type
-        elsif parent_function?
-          @type || superclass.type
-        else
-          @type
-        end
-      end
-
-      def build_field(function)
-        GraphQL::Field.define(
-          arguments: function.arguments,
-          complexity: function.complexity,
-          type: function.type,
-          resolve: function,
-          description: function.description,
-          function: function,
-          deprecation_reason: function.deprecation_reason,
-        )
-      end
-
-      # Class-level reader/writer which is inherited
-      # @api private
-      def self.inherited_value(name)
-        self.class_eval <<-RUBY
-          def #{name}(new_value = nil)
-            if new_value
-              @#{name} = new_value
-            elsif parent_function?
-              @#{name} || superclass.#{name}
-            else
-              @#{name}
-            end
-          end
-        RUBY
-      end
-
-      # @!method description(new_value = nil)
-      #   Get or set this class's description
-      inherited_value(:description)
-      # @!method deprecation_reason(new_value = nil)
-      #   Get or set this class's deprecation_reason
-      inherited_value(:deprecation_reason)
-      # @!method complexity(new_value = nil)
-      #   Get or set this class's complexity
-      inherited_value(:complexity)
-
-      private
-
-      # Does this function inherit from another function?
-      def parent_function?
-        superclass <= GraphQL::Function
-      end
-
-      # Arguments defined on this class (not superclasses)
-      def own_arguments
-        @own_arguments ||= {}
-      end
-    end
-  end
-end

data/lib/graphql/id_type.rb

@@ -1,2 +0,0 @@
-# frozen_string_literal: true
-GraphQL::ID_TYPE = GraphQL::Types::ID.graphql_definition

data/lib/graphql/input_object_type.rb

@@ -1,153 +0,0 @@
-# frozen_string_literal: true
-module GraphQL
-  # {InputObjectType}s are key-value inputs for fields.
-  #
-  # Input objects have _arguments_ which are identical to {GraphQL::Field} arguments.
-  # They map names to types and support default values.
-  # Their input types can be any input types, including {InputObjectType}s.
-  #
-  # @example An input type with name and number
-  #   PlayerInput = GraphQL::InputObjectType.define do
-  #     name("Player")
-  #     argument :name, !types.String
-  #     argument :number, !types.Int
-  #   end
-  #
-  # In a `resolve` function, you can access the values by making nested lookups on `args`.
-  #
-  # @example Accessing input values in a resolve function
-  #   resolve ->(obj, args, ctx) {
-  #     args[:player][:name]    # => "Tony Gwynn"
-  #     args[:player][:number]  # => 19
-  #     args[:player].to_h      # { "name" => "Tony Gwynn", "number" => 19 }
-  #     # ...
-  #   }
-  #
-  class InputObjectType < GraphQL::BaseType
-    accepts_definitions(
-      :arguments, :mutation,
-      input_field: GraphQL::Define::AssignArgument,
-      argument: GraphQL::Define::AssignArgument
-    )
-
-    attr_accessor :mutation, :arguments, :arguments_class
-    ensure_defined(:mutation, :arguments, :input_fields)
-    alias :input_fields :arguments
-
-    # @!attribute mutation
-    #   @return [GraphQL::Relay::Mutation, nil] The mutation this field was derived from, if it was derived from a mutation
-
-    # @!attribute arguments
-    # @return [Hash<String => GraphQL::Argument>] Map String argument names to their {GraphQL::Argument} implementations
-
-
-    def initialize
-      super
-      @arguments = {}
-    end
-
-    def initialize_copy(other)
-      super
-      @arguments = other.arguments.dup
-    end
-
-    def kind
-      GraphQL::TypeKinds::INPUT_OBJECT
-    end
-
-    def coerce_result(value, ctx = nil)
-      if ctx.nil?
-        warn_deprecated_coerce("coerce_isolated_result")
-        ctx = GraphQL::Query::NullContext
-      end
-
-      # Allow the application to provide values as :symbols, and convert them to the strings
-      value = value.reduce({}) { |memo, (k, v)| memo[k.to_s] = v; memo }
-
-      result = {}
-
-      arguments.each do |input_key, input_field_defn|
-        input_value = value[input_key]
-        if value.key?(input_key)
-          result[input_key] = if input_value.nil?
-            nil
-          else
-            input_field_defn.type.coerce_result(input_value, ctx)
-          end
-        end
-      end
-
-      result
-    end
-
-    private
-
-    def coerce_non_null_input(value, ctx)
-      input_values = {}
-      defaults_used = Set.new
-
-      arguments.each do |input_key, input_field_defn|
-        field_value = value[input_key]
-
-        if value.key?(input_key)
-          coerced_value = input_field_defn.type.coerce_input(field_value, ctx)
-          input_values[input_key] = input_field_defn.prepare(coerced_value, ctx)
-        elsif input_field_defn.default_value?
-          coerced_value = input_field_defn.type.coerce_input(input_field_defn.default_value, ctx)
-          input_values[input_key] = coerced_value
-          defaults_used << input_key
-        end
-      end
-
-      arguments_class.new(input_values, context: ctx, defaults_used: defaults_used)
-    end
-
-    # @api private
-    INVALID_OBJECT_MESSAGE = "Expected %{object} to be a key, value object responding to `to_h` or `to_unsafe_h`."
-
-    def validate_non_null_input(input, ctx)
-      warden = ctx.warden
-      result = GraphQL::Query::InputValidationResult.new
-
-      if input.is_a?(Array)
-        result.add_problem(INVALID_OBJECT_MESSAGE % { object: JSON.generate(input, quirks_mode: true) })
-        return result
-      end
-
-      # We're not actually _using_ the coerced result, we're just
-      # using these methods to make sure that the object will
-      # behave like a hash below, when we call `each` on it.
-      begin
-        input.to_h
-      rescue
-        begin
-          # Handle ActionController::Parameters:
-          input.to_unsafe_h
-        rescue
-          # We're not sure it'll act like a hash, so reject it:
-          result.add_problem(INVALID_OBJECT_MESSAGE % { object: JSON.generate(input, quirks_mode: true) })
-          return result
-        end
-      end
-
-      visible_arguments_map = warden.arguments(self).reduce({}) { |m, f| m[f.name] = f; m}
-
-      # Items in the input that are unexpected
-      input.each do |name, value|
-        if visible_arguments_map[name].nil?
-          result.add_problem("Field is not defined on #{self.name}", [name])
-        end
-      end
-
-      # Items in the input that are expected, but have invalid values
-      visible_arguments_map.map do |name, field|
-        field_result = field.type.validate_input(input[name], ctx)
-        if !field_result.valid?
-          result.merge_result!(name, field_result)
-        end
-      end
-
-      result
-    end
-  end
-end

data/lib/graphql/int_type.rb

@@ -1,2 +0,0 @@
-# frozen_string_literal: true
-GraphQL::INT_TYPE = GraphQL::Types::Int.graphql_definition

data/lib/graphql/interface_type.rb

@@ -1,86 +0,0 @@
-# frozen_string_literal: true
-module GraphQL
-  # An Interface contains a collection of types which implement some of the same fields.
-  #
-  # Interfaces can have fields, defined with `field`, just like an object type.
-  #
-  # Objects which implement this field _inherit_ field definitions from the interface.
-  # An object type can override the inherited definition by redefining that field.
-  #
-  # @example An interface with three fields
-  #   DeviceInterface = GraphQL::InterfaceType.define do
-  #     name("Device")
-  #     description("Hardware devices for computing")
-  #
-  #     field :ram, types.String
-  #     field :processor, ProcessorType
-  #     field :release_year, types.Int
-  #   end
-  #
-  # @example Implementing an interface with an object type
-  #   Laptoptype = GraphQL::ObjectType.define do
-  #     interfaces [DeviceInterface]
-  #   end
-  #
-  class InterfaceType < GraphQL::BaseType
-    accepts_definitions :fields, :orphan_types, :resolve_type, field: GraphQL::Define::AssignObjectField
-
-    attr_accessor :fields, :orphan_types, :resolve_type_proc
-    ensure_defined :fields, :orphan_types, :resolve_type_proc, :resolve_type
-
-    def initialize
-      super
-      @fields = {}
-      @orphan_types = []
-      @resolve_type_proc = nil
-    end
-
-    def initialize_copy(other)
-      super
-      @fields = other.fields.dup
-      @orphan_types = other.orphan_types.dup
-    end
-
-    def kind
-      GraphQL::TypeKinds::INTERFACE
-    end
-
-    def resolve_type(value, ctx)
-      ctx.query.resolve_type(self, value)
-    end
-
-    def resolve_type=(resolve_type_callable)
-      @resolve_type_proc = resolve_type_callable
-    end
-
-    # @return [GraphQL::Field] The defined field for `field_name`
-    def get_field(field_name)
-      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 on this type
-    def all_fields
-      fields.values
-    end
-
-    # Get a possible type of this {InterfaceType} by type name
-    # @param type_name [String]
-    # @param ctx [GraphQL::Query::Context] The context for the current query
-    # @return [GraphQL::ObjectType, nil] The type named `type_name` if it exists and implements this {InterfaceType}, (else `nil`)
-    def get_possible_type(type_name, ctx)
-      type = ctx.query.get_type(type_name)
-      type if type && ctx.query.schema.possible_types(self).include?(type)
-    end
-
-    # Check if a type is a possible type of this {InterfaceType}
-    # @param type [String, GraphQL::BaseType] Name of the type or a type definition
-    # @param ctx [GraphQL::Query::Context] The context for the current query
-    # @return [Boolean] True if the `type` exists and is a member of this {InterfaceType}, (else `nil`)
-    def possible_type?(type, ctx)
-      type_name = type.is_a?(String) ? type : type.graphql_name
-      !get_possible_type(type_name, ctx).nil?
-    end
-  end
-end

data/lib/graphql/internal_representation/document.rb

@@ -1,27 +0,0 @@
-# frozen_string_literal: true
-module GraphQL
-  module InternalRepresentation
-    class Document
-      # @return [Hash<String, Node>] Operation Nodes of this query
-      attr_reader :operation_definitions
-
-      # @return [Hash<String, Node>] Fragment definition Nodes of this query
-      attr_reader :fragment_definitions
-
-      def initialize
-        @operation_definitions = {}
-        @fragment_definitions = {}
-      end
-
-      def [](key)
-        warn "#{self.class}#[] is deprecated; use `operation_definitions[]` instead"
-        operation_definitions[key]
-      end
-
-      def each(&block)
-        warn "#{self.class}#each is deprecated; use `operation_definitions.each` instead"
-        operation_definitions.each(&block)
-      end
-    end
-  end
-end

data/lib/graphql/internal_representation/node.rb

@@ -1,206 +0,0 @@
-# frozen_string_literal: true
-module GraphQL
-  module InternalRepresentation
-    class Node
-      # @api private
-      DEFAULT_TYPED_CHILDREN = Proc.new { |h, k| h[k] = {} }
-
-      # A specialized, reusable object for leaf nodes.
-      NO_TYPED_CHILDREN = Hash.new({}.freeze)
-      def NO_TYPED_CHILDREN.dup; self; end;
-      NO_TYPED_CHILDREN.freeze
-
-      # @return [String] the name this node has in the response
-      attr_reader :name
-
-      # @return [GraphQL::ObjectType]
-      attr_reader :owner_type
-
-      # Each key is a {GraphQL::ObjectType} which this selection _may_ be made on.
-      # The values for that key are selections which apply to that type.
-      #
-      # This value is derived from {#scoped_children} after the rewrite is finished.
-      # @return [Hash<GraphQL::ObjectType, Hash<String => Node>>]
-      def typed_children
-        @typed_children ||= begin
-          if @scoped_children.any?
-            new_tc = Hash.new(&DEFAULT_TYPED_CHILDREN)
-            all_object_types = Set.new
-            scoped_children.each_key { |t| all_object_types.merge(@query.possible_types(t)) }
-            # Remove any scoped children which don't follow this return type
-            # (This can happen with fragment merging where lexical scope is lost)
-            all_object_types &= @query.possible_types(@return_type.unwrap)
-            all_object_types.each do |t|
-              new_tc[t] = get_typed_children(t)
-            end
-            new_tc
-          else
-            NO_TYPED_CHILDREN
-          end
-
-        end
-      end
-
-      # These children correspond closely to scopes in the AST.
-      # Keys _may_ be abstract types. They're assumed to be read-only after rewrite is finished
-      # because {#typed_children} is derived from them.
-      #
-      # Using {#scoped_children} during the rewrite step reduces the overhead of reifying
-      # abstract types because they're only reified _after_ the rewrite.
-      # @return [Hash<GraphQL::BaseType, Hash<String => Node>>]
-      attr_reader :scoped_children
-
-      # @return [Array<Language::Nodes::AbstractNode>] AST nodes which are represented by this node
-      attr_reader :ast_nodes
-
-      # @return [Array<GraphQL::Field>] Field definitions for this node (there should only be one!)
-      attr_reader :definitions
-
-      # @return [GraphQL::BaseType] The expected wrapped type this node must return.
-      attr_reader :return_type
-
-      # @return [InternalRepresentation::Node, nil]
-      attr_reader :parent
-
-      def initialize(
-          name:, owner_type:, query:, return_type:, parent:,
-          ast_nodes: [],
-          definitions: []
-        )
-        @name = name
-        @query = query
-        @owner_type = owner_type
-        @parent = parent
-        @typed_children = nil
-        @scoped_children = Hash.new { |h1, k1| h1[k1] = {} }
-        @ast_nodes = ast_nodes
-        @definitions = definitions
-        @return_type = return_type
-      end
-
-      def initialize_copy(other_node)
-        super
-        # Bust some caches:
-        @typed_children = nil
-        @definition = nil
-        @definition_name = nil
-        @ast_node = nil
-        # Shallow-copy some state:
-        @scoped_children = other_node.scoped_children.dup
-        @ast_nodes = other_node.ast_nodes.dup
-        @definitions = other_node.definitions.dup
-      end
-
-      def ==(other)
-        other.is_a?(self.class) &&
-          other.name == name &&
-          other.parent == parent &&
-          other.return_type == return_type &&
-          other.owner_type == owner_type &&
-          other.scoped_children == scoped_children &&
-          other.definitions == definitions &&
-          other.ast_nodes == ast_nodes
-      end
-
-      def definition_name
-        definition && definition.name
-      end
-
-      def arguments
-        @query.arguments_for(self, definition)
-      end
-
-      def definition
-        @definition ||= begin
-          first_def = @definitions.first
-          first_def && @query.get_field(@owner_type, first_def.name)
-        end
-      end
-
-      def ast_node
-        @ast_node ||= ast_nodes.first
-      end
-
-      def inspect
-        all_children_names = scoped_children.values.map(&:keys).flatten.uniq.join(", ")
-        all_locations = ast_nodes.map {|n| "#{n.line}:#{n.col}" }.join(", ")
-        "#<Node #{@owner_type}.#{@name} -> #{@return_type} {#{all_children_names}} @ [#{all_locations}] #{object_id}>"
-      end
-
-      # Merge selections from `new_parent` into `self`.
-      # Selections are merged in place, not copied.
-      def deep_merge_node(new_parent, scope: nil, merge_self: true)
-        if merge_self
-          @ast_nodes |= new_parent.ast_nodes
-          @definitions |= new_parent.definitions
-        end
-        new_sc = new_parent.scoped_children
-        if new_sc.any?
-          scope ||= Scope.new(@query, @return_type.unwrap)
-          new_sc.each do |obj_type, new_fields|
-            inner_scope = scope.enter(obj_type)
-            inner_scope.each do |scoped_type|
-              prev_fields = @scoped_children[scoped_type]
-              new_fields.each do |name, new_node|
-                prev_node = prev_fields[name]
-                if prev_node
-                  prev_node.deep_merge_node(new_node)
-                else
-                  prev_fields[name] = new_node
-                end
-              end
-            end
-          end
-        end
-      end
-
-      # @return [GraphQL::Query]
-      attr_reader :query
-
-      def subscription_topic
-        @subscription_topic ||= begin
-          scope = if definition.subscription_scope
-            @query.context[definition.subscription_scope]
-          else
-            nil
-          end
-          Subscriptions::Event.serialize(
-            definition_name,
-            @query.arguments_for(self, definition),
-            definition,
-            scope: scope
-          )
-        end
-      end
-
-      protected
-
-      attr_writer :owner_type, :parent
-
-      private
-
-      # Get applicable children from {#scoped_children}
-      # @param obj_type [GraphQL::ObjectType]
-      # @return [Hash<String => Node>]
-      def get_typed_children(obj_type)
-        new_tc = {}
-        @scoped_children.each do |scope_type, scope_nodes|
-          if GraphQL::Execution::Typecast.subtype?(scope_type, obj_type)
-            scope_nodes.each do |name, new_node|
-              prev_node = new_tc[name]
-              if prev_node
-                prev_node.deep_merge_node(new_node)
-              else
-                copied_node = new_node.dup
-                copied_node.owner_type = obj_type
-                copied_node.parent = self
-                new_tc[name] = copied_node
-              end
-            end
-          end
-        end
-        new_tc
-      end
-    end
-  end
-end