graphql 1.9.21 → 2.0.0

data/lib/graphql/input_object_type.rb

@@ -1,154 +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
-
-      result = arguments_class.new(input_values, context: ctx, defaults_used: defaults_used)
-      result.prepare
-    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

data/lib/graphql/internal_representation/print.rb

@@ -1,51 +0,0 @@
-# frozen_string_literal: true
-module GraphQL
-  module InternalRepresentation
-    module Print
-      module_function
-
-      def print(schema, query_string)
-        query = GraphQL::Query.new(schema, query_string)
-        print_node(query.irep_selection)
-      end
-
-      def print_node(node, indent: 0)
-        padding = " " * indent
-        typed_children_padding = " " * (indent + 2)
-        query_str = "".dup
-
-        if !node.definition
-          op_node = node.ast_node
-          name = op_node.name ? " " + op_node.name : ""
-          op_type = op_node.operation_type
-          query_str << "#{op_type}#{name}"
-        else
-          if node.name == node.definition_name
-            query_str << "#{padding}#{node.name}"
-          else
-            query_str << "#{padding}#{node.name}: #{node.definition_name}"
-          end
-
-          args = node.ast_nodes.map { |n| n.arguments.map(&:to_query_string).join(",") }.uniq
-          query_str << args.map { |a| "(#{a})"}.join("|")
-        end
-
-        if node.typed_children.any?
-          query_str << " {\n"
-          node.typed_children.each do |type, children|
-            query_str << "#{typed_children_padding}... on #{type.name} {\n"
-            children.each do |name, child|
-              query_str << print_node(child, indent: indent + 4)
-            end
-            query_str << "#{typed_children_padding}}\n"
-          end
-          query_str << "#{padding}}\n"
-        else
-          query_str << "\n"
-        end
-
-        query_str
-      end
-    end
-  end
-end