graphql_cody 1.13.0

data/lib/graphql/language/visitor.rb

@@ -0,0 +1,242 @@
+# frozen_string_literal: true
+module GraphQL
+  module Language
+    # Depth-first traversal through the tree, calling hooks at each stop.
+    #
+    # @example Create a visitor counting certain field names
+    #   class NameCounter < GraphQL::Language::Visitor
+    #     def initialize(document, field_name)
+    #       super(document)
+    #       @field_name = field_name
+    #       @count = 0
+    #     end
+    #
+    #     attr_reader :count
+    #
+    #     def on_field(node, parent)
+    #       # if this field matches our search, increment the counter
+    #       if node.name == @field_name
+    #         @count += 1
+    #       end
+    #       # Continue visiting subfields:
+    #       super
+    #     end
+    #   end
+    #
+    #   # Initialize a visitor
+    #   visitor = NameCounter.new(document, "name")
+    #   # Run it
+    #   visitor.visit
+    #   # Check the result
+    #   visitor.count
+    #   # => 3
+    class Visitor
+      # If any hook returns this value, the {Visitor} stops visiting this
+      # node right away
+      # @deprecated Use `super` to continue the visit; or don't call it to halt.
+      SKIP = :_skip
+
+      class DeleteNode; end
+
+      # When this is returned from a visitor method,
+      # Then the `node` passed into the method is removed from `parent`'s children.
+      DELETE_NODE = DeleteNode.new
+
+      def initialize(document)
+        @document = document
+        @visitors = {}
+        @result = nil
+      end
+
+      # @return [GraphQL::Language::Nodes::Document] The document with any modifications applied
+      attr_reader :result
+
+      # Get a {NodeVisitor} for `node_class`
+      # @param node_class [Class] The node class that you want to listen to
+      # @return [NodeVisitor]
+      #
+      # @example Run a hook whenever you enter a new Field
+      #   visitor[GraphQL::Language::Nodes::Field] << ->(node, parent) { p "Here's a field" }
+      # @deprecated see `on_` methods, like {#on_field}
+      def [](node_class)
+        @visitors[node_class] ||= NodeVisitor.new
+      end
+
+      # Visit `document` and all children, applying hooks as you go
+      # @return [void]
+      def visit
+        result = on_node_with_modifications(@document, nil)
+        @result = if result.is_a?(Array)
+          result.first
+        else
+          # The node wasn't modified
+          @document
+        end
+      end
+
+      # Call the user-defined handler for `node`.
+      def visit_node(node, parent)
+        public_send(node.visit_method, node, parent)
+      end
+
+      # The default implementation for visiting an AST node.
+      # It doesn't _do_ anything, but it continues to visiting the node's children.
+      # To customize this hook, override one of its make_visit_methodes (or the base method?)
+      # in your subclasses.
+      #
+      # For compatibility, it calls hook procs, too.
+      # @param node [GraphQL::Language::Nodes::AbstractNode] the node being visited
+      # @param parent [GraphQL::Language::Nodes::AbstractNode, nil] the previously-visited node, or `nil` if this is the root node.
+      # @return [Array, nil] If there were modifications, it returns an array of new nodes, otherwise, it returns `nil`.
+      def on_abstract_node(node, parent)
+        if node.equal?(DELETE_NODE)
+          # This might be passed to `super(DELETE_NODE, ...)`
+          # by a user hook, don't want to keep visiting in that case.
+          nil
+        else
+          # Run hooks if there are any
+          new_node = node
+          no_hooks = !@visitors.key?(node.class)
+          if no_hooks || begin_visit(new_node, parent)
+            node.children.each do |child_node|
+              new_child_and_node = on_node_with_modifications(child_node, new_node)
+              # Reassign `node` in case the child hook makes a modification
+              if new_child_and_node.is_a?(Array)
+                new_node = new_child_and_node[1]
+              end
+            end
+          end
+          end_visit(new_node, parent) unless no_hooks
+
+          if new_node.equal?(node)
+            nil
+          else
+            [new_node, parent]
+          end
+        end
+      end
+
+      # We don't use `alias` here because it breaks `super`
+      def self.make_visit_method(node_method)
+        class_eval(<<-RUBY, __FILE__, __LINE__ + 1)
+          def #{node_method}(node, parent)
+            child_mod = on_abstract_node(node, parent)
+            # If visiting the children returned changes, continue passing those.
+            child_mod || [node, parent]
+          end
+        RUBY
+      end
+
+      make_visit_method :on_argument
+      make_visit_method :on_directive
+      make_visit_method :on_directive_definition
+      make_visit_method :on_directive_location
+      make_visit_method :on_document
+      make_visit_method :on_enum
+      make_visit_method :on_enum_type_definition
+      make_visit_method :on_enum_type_extension
+      make_visit_method :on_enum_value_definition
+      make_visit_method :on_field
+      make_visit_method :on_field_definition
+      make_visit_method :on_fragment_definition
+      make_visit_method :on_fragment_spread
+      make_visit_method :on_inline_fragment
+      make_visit_method :on_input_object
+      make_visit_method :on_input_object_type_definition
+      make_visit_method :on_input_object_type_extension
+      make_visit_method :on_input_value_definition
+      make_visit_method :on_interface_type_definition
+      make_visit_method :on_interface_type_extension
+      make_visit_method :on_list_type
+      make_visit_method :on_non_null_type
+      make_visit_method :on_null_value
+      make_visit_method :on_object_type_definition
+      make_visit_method :on_object_type_extension
+      make_visit_method :on_operation_definition
+      make_visit_method :on_scalar_type_definition
+      make_visit_method :on_scalar_type_extension
+      make_visit_method :on_schema_definition
+      make_visit_method :on_schema_extension
+      make_visit_method :on_type_name
+      make_visit_method :on_union_type_definition
+      make_visit_method :on_union_type_extension
+      make_visit_method :on_variable_definition
+      make_visit_method :on_variable_identifier
+
+      private
+
+      # Run the hooks for `node`, and if the hooks return a copy of `node`,
+      # copy `parent` so that it contains the copy of that node as a child,
+      # then return the copies
+      # If a non-array value is returned, consuming functions should ignore
+      # said value
+      def on_node_with_modifications(node, parent)
+        new_node_and_new_parent = visit_node(node, parent)
+        if new_node_and_new_parent.is_a?(Array)
+          new_node = new_node_and_new_parent[0]
+          new_parent = new_node_and_new_parent[1]
+          if new_node.is_a?(Nodes::AbstractNode) && !node.equal?(new_node)
+            # The user-provided hook returned a new node.
+            new_parent = new_parent && new_parent.replace_child(node, new_node)
+            return new_node, new_parent
+          elsif new_node.equal?(DELETE_NODE)
+            # The user-provided hook requested to remove this node
+            new_parent = new_parent && new_parent.delete_child(node)
+            return nil, new_parent
+          elsif new_node_and_new_parent.none? { |n| n == nil || n.class < Nodes::AbstractNode }
+            # The user-provided hook returned an array of who-knows-what
+            # return nil here to signify that no changes should be made
+            nil
+          else
+            new_node_and_new_parent
+          end
+        else
+          # The user-provided hook didn't make any modifications.
+          # In fact, the hook might have returned who-knows-what, so
+          # ignore the return value and use the original values.
+          new_node_and_new_parent
+        end
+      end
+
+      def begin_visit(node, parent)
+        node_visitor = self[node.class]
+        self.class.apply_hooks(node_visitor.enter, node, parent)
+      end
+
+      # Should global `leave` visitors come first or last?
+      def end_visit(node, parent)
+        node_visitor = self[node.class]
+        self.class.apply_hooks(node_visitor.leave, node, parent)
+      end
+
+      # If one of the visitors returns SKIP, stop visiting this node
+      def self.apply_hooks(hooks, node, parent)
+        hooks.each do |proc|
+          return false if proc.call(node, parent) == SKIP
+        end
+        true
+      end
+
+      # Collect `enter` and `leave` hooks for classes in {GraphQL::Language::Nodes}
+      #
+      # Access {NodeVisitor}s via {GraphQL::Language::Visitor#[]}
+      class NodeVisitor
+        # @return [Array<Proc>] Hooks to call when entering a node of this type
+        attr_reader :enter
+        # @return [Array<Proc>] Hooks to call when leaving a node of this type
+        attr_reader :leave
+
+        def initialize
+          @enter = []
+          @leave = []
+        end
+
+        # Shorthand to add a hook to the {#enter} array
+        # @param hook [Proc] A hook to add
+        def <<(hook)
+          enter << hook
+        end
+      end
+    end
+  end
+end

data/lib/graphql/language.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+require "graphql/language/block_string"
+require "graphql/language/printer"
+require "graphql/language/sanitized_printer"
+require "graphql/language/document_from_schema_definition"
+require "graphql/language/generation"
+require "graphql/language/lexer"
+require "graphql/language/nodes"
+require "graphql/language/cache"
+require "graphql/language/parser"
+require "graphql/language/token"
+require "graphql/language/visitor"
+require "graphql/language/definition_slice"
+
+module GraphQL
+  module Language
+    # @api private
+    def self.serialize(value)
+      if value.is_a?(Hash)
+        serialized_hash = value.map do |k, v|
+          "#{k}:#{serialize v}"
+        end.join(",")
+
+        "{#{serialized_hash}}"
+      elsif value.is_a?(Array)
+        serialized_array = value.map do |v|
+          serialize v
+        end.join(",")
+
+        "[#{serialized_array}]"
+      else
+        JSON.generate(value, quirks_mode: true)
+      end
+    end
+  end
+end

data/lib/graphql/list_type.rb

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+module GraphQL
+  # A list type modifies another type.
+  #
+  # List types can be created with the type helper (`types[InnerType]`)
+  # or {BaseType#to_list_type} (`InnerType.to_list_type`)
+  #
+  # For return types, it says that the returned value will be a list of the modified.
+  #
+  # @example A field which returns a list of items
+  #   field :items, types[ItemType]
+  #   # or
+  #   field :items, ItemType.to_list_type
+  #
+  # For input types, it says that the incoming value will be a list of the modified type.
+  #
+  # @example A field which accepts a list of strings
+  #   field :newNames do
+  #     # ...
+  #     argument :values, types[types.String]
+  #     # or
+  #     argument :values, types.String.to_list_type
+  #   end
+  #
+  # Given a list type, you can always get the underlying type with {#unwrap}.
+  #
+  class ListType < GraphQL::BaseType
+    include GraphQL::BaseType::ModifiesAnotherType
+    attr_reader :of_type
+    def initialize(of_type:)
+      super()
+      @of_type = of_type
+    end
+
+    def kind
+      GraphQL::TypeKinds::LIST
+    end
+
+    def to_s
+      "[#{of_type.to_s}]"
+    end
+    alias_method :inspect, :to_s
+    alias :to_type_signature :to_s
+
+    def coerce_result(value, ctx = nil)
+      if ctx.nil?
+        warn_deprecated_coerce("coerce_isolated_result")
+        ctx = GraphQL::Query::NullContext
+      end
+      ensure_array(value).map { |item| item.nil? ? nil : of_type.coerce_result(item, ctx) }
+    end
+
+    def list?
+      true
+    end
+
+    private
+
+    def coerce_non_null_input(value, ctx)
+      ensure_array(value).map { |item| of_type.coerce_input(item, ctx) }
+    end
+
+    def validate_non_null_input(value, ctx)
+      result = GraphQL::Query::InputValidationResult.new
+
+      ensure_array(value).each_with_index do |item, index|
+        item_result = of_type.validate_input(item, ctx)
+        if !item_result.valid?
+          result.merge_result!(index, item_result)
+        end
+      end
+
+      result
+    end
+
+    def ensure_array(value)
+      value.is_a?(Array) ? value : [value]
+    end
+  end
+end

data/lib/graphql/load_application_object_failed_error.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module GraphQL
+  # Raised when a argument is configured with `loads:` and the client provides an `ID`,
+  # but no object is loaded for that ID.
+  #
+  # @see GraphQL::Schema::Member::HasArguments::ArgumentObjectLoader#load_application_object_failed, A hook which you can override in resolvers, mutations and input objects.
+  class LoadApplicationObjectFailedError < GraphQL::ExecutionError
+    # @return [GraphQL::Schema::Argument] the argument definition for the argument that was looked up
+    attr_reader :argument
+    # @return [String] The ID provided by the client
+    attr_reader :id
+    # @return [Object] The value found with this ID
+    attr_reader :object
+    def initialize(argument:, id:, object:)
+      @id = id
+      @argument = argument
+      @object = object
+      super("No object found for `#{argument.graphql_name}: #{id.inspect}`")
+    end
+  end
+end

data/lib/graphql/name_validator.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+module GraphQL
+  class NameValidator
+    VALID_NAME_REGEX = /^[_a-zA-Z][_a-zA-Z0-9]*$/
+
+    def self.validate!(name)
+      name = name.is_a?(String) ? name : name.to_s
+      raise GraphQL::InvalidNameError.new(name, VALID_NAME_REGEX) unless name.match?(VALID_NAME_REGEX)
+    end
+  end
+end

data/lib/graphql/non_null_type.rb

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

@@ -0,0 +1,130 @@
+# 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/pagination/active_record_relation_connection.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+require "graphql/pagination/relation_connection"
+
+module GraphQL
+  module Pagination
+    # Customizes `RelationConnection` to work with `ActiveRecord::Relation`s.
+    class ActiveRecordRelationConnection < Pagination::RelationConnection
+      private
+
+      def relation_larger_than(relation, size)
+        initial_offset = relation.offset_value || 0
+        relation.offset(initial_offset + size).exists?
+      end
+
+      def relation_count(relation)
+        int_or_hash = if relation.respond_to?(:unscope)
+          relation.unscope(:order).count(:all)
+        else
+          # Rails 3
+          relation.count
+        end
+        if int_or_hash.is_a?(Integer)
+          int_or_hash
+        else
+          # Grouped relations return count-by-group hashes
+          int_or_hash.length
+        end
+      end
+
+      def relation_limit(relation)
+        relation.limit_value
+      end
+
+      def relation_offset(relation)
+        relation.offset_value
+      end
+
+      def null_relation(relation)
+        if relation.respond_to?(:none)
+          relation.none
+        else
+          # Rails 3
+          relation.where("1=2")
+        end
+      end
+    end
+  end
+end