graphql_cody 1.13.0

data/lib/graphql/function.rb

@@ -0,0 +1,128 @@
+# frozen_string_literal: true
+module GraphQL
+  # @api deprecated
+  class Function
+    def self.inherited(subclass)
+      GraphQL::Deprecation.warn "GraphQL::Function (used for #{subclass}) will be removed from GraphQL-Ruby 2.0, please upgrade to resolvers: https://graphql-ruby.org/fields/resolvers.html"
+    end
+
+    # @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 GraphQL::RequiredImplementationMissingError
+    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

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

data/lib/graphql/input_object_type.rb

@@ -0,0 +1,138 @@
+# frozen_string_literal: true
+module GraphQL
+  # @api deprecated
+  class InputObjectType < GraphQL::BaseType
+    extend Define::InstanceDefinable::DeprecatedDefine
+
+    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
+
+    def get_argument(argument_name)
+      arguments[argument_name]
+    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.graphql_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

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

data/lib/graphql/integer_decoding_error.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+module GraphQL
+  # This error is raised when `Types::Int` is given an input value outside of 32-bit integer range.
+  #
+  # For really big integer values, consider `GraphQL::Types::BigInt`
+  #
+  # @see GraphQL::Types::Int which raises this error
+  class IntegerDecodingError < GraphQL::RuntimeTypeError
+    # The value which couldn't be decoded
+    attr_reader :integer_value
+
+    def initialize(value)
+      @integer_value = value
+      super("Integer out of bounds: #{value}. \nConsider using GraphQL::Types::BigInt instead.")
+    end
+  end
+end

data/lib/graphql/integer_encoding_error.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+module GraphQL
+  # This error is raised when `Types::Int` is asked to return a value outside of 32-bit integer range.
+  #
+  # For values outside that range, consider:
+  #
+  # - `ID` for database primary keys or other identifiers
+  # - `GraphQL::Types::BigInt` for really big integer values
+  #
+  # @see GraphQL::Types::Int which raises this error
+  class IntegerEncodingError < GraphQL::RuntimeTypeError
+    # The value which couldn't be encoded
+    attr_reader :integer_value
+
+    # @return [GraphQL::Schema::Field] The field that returned a too-big integer
+    attr_reader :field
+
+    # @return [Array<String, Integer>] Where the field appeared in the GraphQL response
+    attr_reader :path
+
+    def initialize(value, context:)
+      @integer_value = value
+      @field = context[:current_field]
+      @path = context[:current_path]
+      message = "Integer out of bounds: #{value}".dup
+      if @path
+        message << " @ #{@path.join(".")}"
+      end
+      if @field
+        message << " (#{@field.path})"
+      end
+      message << ". Consider using ID or GraphQL::Types::BigInt instead."
+      super(message)
+    end
+  end
+end

data/lib/graphql/interface_type.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+module GraphQL
+  # @api deprecated
+  class InterfaceType < GraphQL::BaseType
+    extend Define::InstanceDefinable::DeprecatedDefine
+
+    accepts_definitions :fields, :orphan_types, :resolve_type, field: GraphQL::Define::AssignObjectField
+
+    attr_accessor :fields, :orphan_types, :resolve_type_proc
+    attr_writer :type_membership_class
+    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.warden.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
+
+    def type_membership_class
+      @type_membership_class || GraphQL::Schema::TypeMembership
+    end
+  end
+end

data/lib/graphql/internal_representation/document.rb

@@ -0,0 +1,27 @@
+# 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)
+        GraphQL::Deprecation.warn "#{self.class}#[] is deprecated; use `operation_definitions[]` instead"
+        operation_definitions[key]
+      end
+
+      def each(&block)
+        GraphQL::Deprecation.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

@@ -0,0 +1,206 @@
+# 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

@@ -0,0 +1,51 @@
+# 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