graphql_cody 1.13.0

data/lib/graphql/relay/mongo_relation_connection.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+module GraphQL
+  module Relay
+    # A connection implementation to expose MongoDB collection objects.
+    # It works for:
+    # - `Mongoid::Criteria`
+    class MongoRelationConnection < RelationConnection
+      private
+
+      def relation_offset(relation)
+        relation.options.skip
+      end
+
+      def relation_limit(relation)
+        relation.options.limit
+      end
+
+      def relation_count(relation)
+        # Must perform query (hence #to_a) to count results https://jira.mongodb.org/browse/MONGOID-2325
+        relation.to_a.count
+      end
+
+      def limit_nodes(sliced_nodes, limit)
+        if limit == 0
+          if sliced_nodes.respond_to?(:none) # added in Mongoid 4.0
+            sliced_nodes.without_options.none
+          else
+            sliced_nodes.where(id: nil) # trying to simulate #none for 3.1.7
+          end
+        else
+          sliced_nodes.limit(limit)
+        end
+      end
+    end
+
+    if defined?(Mongoid::Criteria)
+      BaseConnection.register_connection_implementation(Mongoid::Criteria, MongoRelationConnection)
+    end
+
+    # Mongoid 5 and 6
+    if defined?(Mongoid::Relations::Targets::Enumerable)
+      BaseConnection.register_connection_implementation(Mongoid::Relations::Targets::Enumerable, MongoRelationConnection)
+    end
+
+    # Mongoid 7
+    if defined?(Mongoid::Association::Referenced::HasMany::Targets::Enumerable)
+      BaseConnection.register_connection_implementation(Mongoid::Association::Referenced::HasMany::Targets::Enumerable, MongoRelationConnection)
+    end
+  end
+end

data/lib/graphql/relay/mutation/instrumentation.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+module GraphQL
+  module Relay
+    class Mutation
+      # @api private
+      module Instrumentation
+        # Modify mutation `return_field` resolves by wrapping the returned object
+        # in a {Mutation::Result}.
+        #
+        # By using an instrumention, we can apply our wrapper _last_,
+        # giving users access to the original resolve function in earlier instrumentation.
+        def self.instrument(type, field)
+          if field.mutation.is_a?(GraphQL::Relay::Mutation) || (field.mutation.is_a?(Class) && field.mutation < GraphQL::Schema::RelayClassicMutation)
+            new_resolve = Mutation::Resolve.new(field.mutation, field.resolve_proc)
+            field.redefine(resolve: new_resolve)
+          else
+            field
+          end
+        end
+      end
+    end
+  end
+end

data/lib/graphql/relay/mutation/resolve.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+module GraphQL
+  module Relay
+    class Mutation
+      # Wrap a user-provided resolve function,
+      # wrapping the returned value in a {Mutation::Result}.
+      # Also, pass the `clientMutationId` to that result object.
+      # @api private
+      class Resolve
+        def initialize(mutation, resolve)
+          @mutation = mutation
+          @resolve = resolve
+          @wrap_result = mutation.is_a?(GraphQL::Relay::Mutation) && mutation.has_generated_return_type?
+          @class_based = mutation.is_a?(Class)
+        end
+
+        def call(obj, args, ctx)
+          mutation_result = begin
+            @resolve.call(obj, args[:input], ctx)
+          rescue GraphQL::ExecutionError => err
+            err
+          end
+
+          ctx.schema.after_lazy(mutation_result) do |res|
+            build_result(res, args, ctx)
+          end
+        end
+
+        private
+
+        def build_result(mutation_result, args, ctx)
+          if mutation_result.is_a?(GraphQL::ExecutionError)
+            ctx.add_error(mutation_result)
+            mutation_result = nil
+          end
+
+          if mutation_result.nil?
+            nil
+          elsif @wrap_result
+            if mutation_result && !mutation_result.is_a?(Hash)
+              raise StandardError, "Expected `#{mutation_result}` to be a Hash."\
+                " Return a hash when using `return_field` or specify a custom `return_type`."
+            end
+
+            @mutation.result_class.new(client_mutation_id: args[:input][:clientMutationId], result: mutation_result)
+          elsif @class_based
+            mutation_result[:client_mutation_id] = args[:input][:client_mutation_id]
+            mutation_result
+          else
+            mutation_result
+          end
+        end
+      end
+    end
+  end
+end

data/lib/graphql/relay/mutation/result.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+module GraphQL
+  module Relay
+    class Mutation
+      # Use this when the mutation's return type was generated from `return_field`s.
+      # It delegates field lookups to the hash returned from `resolve`.
+      # @api private
+      class Result
+        attr_reader :client_mutation_id
+        def initialize(client_mutation_id:, result:)
+          @client_mutation_id = client_mutation_id
+          result && result.each do |key, value|
+            self.public_send("#{key}=", value)
+          end
+        end
+
+        class << self
+          attr_accessor :mutation
+        end
+
+        # Build a subclass whose instances have a method
+        # for each of `mutation_defn`'s `return_field`s
+        # @param mutation_defn [GraphQL::Relay::Mutation]
+        # @return [Class]
+        def self.define_subclass(mutation_defn)
+          subclass = Class.new(self) do
+            mutation_result_methods = mutation_defn.return_type.all_fields.map do |f|
+              f.property || f.name
+            end
+            attr_accessor(*mutation_result_methods)
+            self.mutation = mutation_defn
+          end
+          subclass
+        end
+      end
+    end
+  end
+end

data/lib/graphql/relay/mutation.rb

@@ -0,0 +1,106 @@
+# frozen_string_literal: true
+require "graphql/relay/mutation/instrumentation"
+require "graphql/relay/mutation/resolve"
+require "graphql/relay/mutation/result"
+
+module GraphQL
+  module Relay
+    # @api deprecated
+    class Mutation
+      include GraphQL::Define::InstanceDefinable
+      accepts_definitions(
+        :name, :description, :resolve,
+        :return_type,
+        :return_interfaces,
+        input_field: GraphQL::Define::AssignArgument,
+        return_field: GraphQL::Define::AssignObjectField,
+        function: GraphQL::Define::AssignMutationFunction,
+      )
+      attr_accessor :name, :description, :fields, :arguments
+      attr_writer :return_type, :return_interfaces
+
+      ensure_defined(
+        :input_fields, :return_fields, :name, :description,
+        :fields, :arguments, :return_type,
+        :return_interfaces, :resolve=,
+        :field, :result_class, :input_type
+      )
+      # For backwards compat, but do we need this separate API?
+      alias :return_fields :fields
+      alias :input_fields :arguments
+
+      def initialize
+        GraphQL::Deprecation.warn "GraphQL::Relay::Mutation will be removed from GraphQL-Ruby 2.0, use GraphQL::Schema::RelayClassicMutation instead: https://graphql-ruby.org/mutations/mutation_classes"
+        @fields = {}
+        @arguments = {}
+        @has_generated_return_type = false
+      end
+
+      def has_generated_return_type?
+        # Trigger the generation of the return type, if it is dynamically generated:
+        return_type
+        @has_generated_return_type
+      end
+
+      def resolve=(new_resolve_proc)
+        @resolve_proc = new_resolve_proc
+      end
+
+      def field
+        @field ||= begin
+          relay_mutation = self
+          field_resolve_proc = @resolve_proc
+          GraphQL::Field.define do
+            type(relay_mutation.return_type)
+            description(relay_mutation.description)
+            argument :input, !relay_mutation.input_type
+            resolve(field_resolve_proc)
+            mutation(relay_mutation)
+          end
+        end
+      end
+
+      def return_interfaces
+        @return_interfaces ||= []
+      end
+
+      def return_type
+        @return_type ||= begin
+          @has_generated_return_type = true
+          relay_mutation = self
+          GraphQL::ObjectType.define do
+            name("#{relay_mutation.name}Payload")
+            description("Autogenerated return type of #{relay_mutation.name}")
+            field :clientMutationId, types.String, "A unique identifier for the client performing the mutation.", property: :client_mutation_id
+            interfaces relay_mutation.return_interfaces
+            relay_mutation.return_fields.each do |name, field_obj|
+              field name, field: field_obj
+            end
+            mutation(relay_mutation)
+          end
+        end
+      end
+
+      def input_type
+        @input_type ||= begin
+          relay_mutation = self
+          input_object_type = GraphQL::InputObjectType.define do
+            name("#{relay_mutation.name}Input")
+            description("Autogenerated input type of #{relay_mutation.name}")
+            input_field :clientMutationId, types.String, "A unique identifier for the client performing the mutation."
+            mutation(relay_mutation)
+          end
+          input_fields.each do |name, arg|
+            input_object_type.arguments[name] = arg
+          end
+
+          input_object_type
+        end
+      end
+
+      def result_class
+        @result_class ||= Result.define_subclass(self)
+      end
+    end
+  end
+end

data/lib/graphql/relay/node.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+module GraphQL
+  module Relay
+    # Helpers for working with Relay-specific Node objects.
+    module Node
+      # @return [GraphQL::Field] a field for finding objects by their global ID.
+      def self.field(**kwargs, &block)
+        GraphQL::Deprecation.warn "GraphQL::Relay::Node.field will be removed from GraphQL-Ruby 2.0, use GraphQL::Types::Relay::NodeField instead"
+        # We have to define it fresh each time because
+        # its name will be modified and its description
+        # _may_ be modified.
+        field = GraphQL::Types::Relay::NodeField.graphql_definition
+
+        if kwargs.any? || block
+          field = field.redefine(**kwargs, &block)
+        end
+
+        field
+      end
+
+      def self.plural_field(**kwargs, &block)
+        GraphQL::Deprecation.warn "GraphQL::Relay::Nodes.field will be removed from GraphQL-Ruby 2.0, use GraphQL::Types::Relay::NodesField instead"
+        field = GraphQL::Types::Relay::NodesField.graphql_definition
+
+        if kwargs.any? || block
+          field = field.redefine(**kwargs, &block)
+        end
+
+        field
+      end
+
+      # @return [GraphQL::InterfaceType] The interface which all Relay types must implement
+      def self.interface
+        GraphQL::Deprecation.warn "GraphQL::Relay::Node.interface will be removed from GraphQL-Ruby 2.0, use GraphQL::Types::Relay::Node instead"
+        @interface ||= GraphQL::Types::Relay::Node.graphql_definition
+      end
+    end
+  end
+end

data/lib/graphql/relay/page_info.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+module GraphQL
+  module Relay
+    # Wrap a Connection and expose its page info
+    PageInfo = GraphQL::Types::Relay::PageInfo.graphql_definition
+  end
+end

data/lib/graphql/relay/range_add.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+module GraphQL
+  module Relay
+    # This provides some isolation from `GraphQL::Relay` internals.
+    #
+    # Given a list of items and a new item, it will provide a connection and an edge.
+    #
+    # The connection doesn't receive outside arguments, so the list of items
+    # should be ordered and paginated before providing it here.
+    #
+    # @example Adding a comment to list of comments
+    #   post = Post.find(args[:post_id])
+    #   comments = post.comments
+    #   new_comment = comments.build(body: args[:body])
+    #   new_comment.save!
+    #
+    #   range_add = GraphQL::Relay::RangeAdd.new(
+    #     parent: post,
+    #     collection: comments,
+    #     item: new_comment,
+    #     context: context,
+    #   )
+    #
+    #   response = {
+    #     post: post,
+    #     comments_connection: range_add.connection,
+    #     new_comment_edge: range_add.edge,
+    #   }
+    class RangeAdd
+      attr_reader :edge, :connection, :parent
+
+      # @param collection [Object] The list of items to wrap in a connection
+      # @param item [Object] The newly-added item (will be wrapped in `edge_class`)
+      # @param parent [Object] The owner of `collection`, will be passed to the connection if provided
+      # @param context [GraphQL::Query::Context] The surrounding `ctx`, will be passed to the connection if provided (this is required for cursor encoders)
+      # @param edge_class [Class] The class to wrap `item` with (defaults to the connection's edge class)
+      def initialize(collection:, item:, parent: nil, context: nil, edge_class: nil)
+        if context && context.schema.new_connections?
+          conn_class = context.schema.connections.wrapper_for(collection)
+          # The rest will be added by ConnectionExtension
+          @connection = conn_class.new(collection, parent: parent, context: context, edge_class: edge_class)
+          # Check if this connection supports it, to support old versions of GraphQL-Pro
+          @edge = if @connection.respond_to?(:range_add_edge)
+            @connection.range_add_edge(item)
+          else
+            @connection.edge_class.new(item, @connection)
+          end
+        else
+          connection_class = BaseConnection.connection_for_nodes(collection)
+          @connection = connection_class.new(collection, {}, parent: parent, context: context)
+          edge_class ||= Relay::Edge
+          @edge = edge_class.new(item, @connection)
+        end
+
+        @parent = parent
+      end
+    end
+  end
+end

data/lib/graphql/relay/relation_connection.rb

@@ -0,0 +1,188 @@
+# frozen_string_literal: true
+module GraphQL
+  module Relay
+    # A connection implementation to expose SQL collection objects.
+    # It works for:
+    # - `ActiveRecord::Relation`
+    # - `Sequel::Dataset`
+    class RelationConnection < BaseConnection
+      def cursor_from_node(item)
+        item_index = paged_nodes.index(item)
+        if item_index.nil?
+          raise("Can't generate cursor, item not found in connection: #{item}")
+        else
+          offset = item_index + 1 + ((paged_nodes_offset || 0) - (relation_offset(sliced_nodes) || 0))
+
+          if after
+            offset += offset_from_cursor(after)
+          elsif before
+            offset += offset_from_cursor(before) - 1 - sliced_nodes_count
+          end
+
+          encode(offset.to_s)
+        end
+      end
+
+      def has_next_page
+        if first
+          if defined?(ActiveRecord::Relation) && nodes.is_a?(ActiveRecord::Relation)
+            initial_offset = after ? offset_from_cursor(after) : 0
+            return paged_nodes.length >= first && nodes.offset(first + initial_offset).exists?
+          end
+          return paged_nodes.length >= first && sliced_nodes_count > first
+        end
+        if GraphQL::Relay::ConnectionType.bidirectional_pagination && last
+          return sliced_nodes_count >= last
+        end
+        false
+      end
+
+      def has_previous_page
+        if last
+          paged_nodes.length >= last && sliced_nodes_count > last
+        elsif GraphQL::Relay::ConnectionType.bidirectional_pagination && after
+          # We've already paginated through the collection a bit,
+          # there are nodes behind us
+          offset_from_cursor(after) > 0
+        else
+          false
+        end
+      end
+
+      def first
+        @first ||= begin
+          capped = limit_pagination_argument(arguments[:first], max_page_size)
+          if capped.nil? && last.nil?
+            capped = max_page_size
+          end
+          capped
+        end
+      end
+
+      def last
+        @last ||= limit_pagination_argument(arguments[:last], max_page_size)
+      end
+
+      private
+
+      # apply first / last limit results
+      # @return [Array]
+      def paged_nodes
+        return @paged_nodes if defined? @paged_nodes
+
+        items = sliced_nodes
+
+        if first
+          if relation_limit(items).nil? || relation_limit(items) > first
+            items = items.limit(first)
+          end
+        end
+
+        if last
+          if relation_limit(items)
+            if last <= relation_limit(items)
+              offset = (relation_offset(items) || 0) + (relation_limit(items) - last)
+              items = items.offset(offset).limit(last)
+            end
+          else
+            slice_count = relation_count(items)
+            offset = (relation_offset(items) || 0) + slice_count - [last, slice_count].min
+            items = items.offset(offset).limit(last)
+          end
+        end
+
+        if max_page_size && !first && !last
+          if relation_limit(items).nil? || relation_limit(items) > max_page_size
+            items = items.limit(max_page_size)
+          end
+        end
+
+        # Store this here so we can convert the relation to an Array
+        # (this avoids an extra DB call on Sequel)
+        @paged_nodes_offset = relation_offset(items)
+        @paged_nodes = items.to_a
+      end
+
+      def paged_nodes_offset
+        paged_nodes && @paged_nodes_offset
+      end
+
+      def relation_offset(relation)
+        if relation.respond_to?(:offset_value)
+          relation.offset_value
+        else
+          relation.opts[:offset]
+        end
+      end
+
+      def relation_limit(relation)
+        if relation.respond_to?(:limit_value)
+          relation.limit_value
+        else
+          relation.opts[:limit]
+        end
+      end
+
+      # If a relation contains a `.group` clause, a `.count` will return a Hash.
+      def relation_count(relation)
+        count_or_hash = if(defined?(ActiveRecord::Relation) && relation.is_a?(ActiveRecord::Relation))
+          relation.respond_to?(:unscope)? relation.unscope(:order).count(:all) : relation.count(:all)
+        else # eg, Sequel::Dataset, don't mess up others
+          relation.count
+        end
+        count_or_hash.is_a?(Integer) ? count_or_hash : count_or_hash.length
+      end
+
+      # Apply cursors to edges
+      def sliced_nodes
+        return @sliced_nodes if defined? @sliced_nodes
+
+        @sliced_nodes = nodes
+
+        if after
+          offset = (relation_offset(@sliced_nodes) || 0) + offset_from_cursor(after)
+          @sliced_nodes = @sliced_nodes.offset(offset)
+        end
+
+        if before && after
+          if offset_from_cursor(after) < offset_from_cursor(before)
+            @sliced_nodes = limit_nodes(@sliced_nodes,  offset_from_cursor(before) - offset_from_cursor(after) - 1)
+          else
+            @sliced_nodes = limit_nodes(@sliced_nodes, 0)
+          end
+
+        elsif before
+          @sliced_nodes = limit_nodes(@sliced_nodes, offset_from_cursor(before) - 1)
+        end
+
+        @sliced_nodes
+      end
+
+      def limit_nodes(sliced_nodes, limit)
+        if limit > 0 || defined?(ActiveRecord::Relation) && sliced_nodes.is_a?(ActiveRecord::Relation)
+          sliced_nodes.limit(limit)
+        else
+          sliced_nodes.where(false)
+        end
+      end
+
+      def sliced_nodes_count
+        return @sliced_nodes_count if defined? @sliced_nodes_count
+
+        # If a relation contains a `.group` clause, a `.count` will return a Hash.
+        @sliced_nodes_count = relation_count(sliced_nodes)
+      end
+
+      def offset_from_cursor(cursor)
+        decode(cursor).to_i
+      end
+    end
+
+    if defined?(ActiveRecord::Relation)
+      BaseConnection.register_connection_implementation(ActiveRecord::Relation, RelationConnection)
+    end
+    if defined?(Sequel::Dataset)
+      BaseConnection.register_connection_implementation(Sequel::Dataset, RelationConnection)
+    end
+  end
+end

data/lib/graphql/relay/type_extensions.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+module GraphQL
+  module Relay
+    # Mixin for Relay-related methods in type objects
+    # (used by BaseType and Schema::Member).
+    module TypeExtensions
+      # @return [GraphQL::ObjectType] The default connection type for this object type
+      def connection_type
+        @connection_type ||= define_connection
+      end
+
+      # Define a custom connection type for this object type
+      # @return [GraphQL::ObjectType]
+      def define_connection(**kwargs, &block)
+        GraphQL::Deprecation.warn ".connection_type and .define_connection will be removed from GraphQL-Ruby 2.0, use class-based type definitions instead: https://graphql-ruby.org/schema/class_based_api.html"
+        GraphQL::Relay::ConnectionType.create_type(self, **kwargs, &block)
+      end
+
+      # @return [GraphQL::ObjectType] The default edge type for this object type
+      def edge_type
+        @edge_type ||= define_edge
+      end
+
+      # Define a custom edge type for this object type
+      # @return [GraphQL::ObjectType]
+      def define_edge(**kwargs, &block)
+        GraphQL::Deprecation.warn ".edge_type and .define_edge will be removed from GraphQL-Ruby 2.0, use class-based type definitions instead: https://graphql-ruby.org/schema/class_based_api.html"
+        GraphQL::Relay::EdgeType.create_type(self, **kwargs, &block)
+      end
+    end
+  end
+end

data/lib/graphql/relay.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+require 'graphql/relay/page_info'
+require 'graphql/relay/edge'
+require 'graphql/relay/edge_type'
+require 'graphql/relay/edges_instrumentation'
+require 'graphql/relay/base_connection'
+require 'graphql/relay/array_connection'
+require 'graphql/relay/range_add'
+require 'graphql/relay/relation_connection'
+require 'graphql/relay/mongo_relation_connection'
+require 'graphql/relay/global_id_resolve'
+require 'graphql/relay/mutation'
+require 'graphql/relay/node'
+require 'graphql/relay/connection_instrumentation'
+require 'graphql/relay/connection_resolve'
+require 'graphql/relay/connection_type'
+require 'graphql/relay/type_extensions'

data/lib/graphql/rubocop/graphql/base_cop.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+require "rubocop"
+
+module GraphQL
+  module Rubocop
+    module GraphQL
+      class BaseCop < RuboCop::Cop::Base
+        extend RuboCop::Cop::AutoCorrector
+
+        # Return the source of `send_node`, but without the keyword argument represented by `pair_node`
+        def source_without_keyword_argument(send_node, pair_node)
+          # work back to the preceeding comma
+          first_pos = pair_node.location.expression.begin_pos
+          end_pos = pair_node.location.expression.end_pos
+          node_source = send_node.source_range.source
+          node_first_pos = send_node.location.expression.begin_pos
+
+          relative_first_pos = first_pos - node_first_pos
+          relative_last_pos = end_pos - node_first_pos
+
+          begin_removal_pos = relative_first_pos
+          while node_source[begin_removal_pos] != ","
+            begin_removal_pos -= 1
+            if begin_removal_pos < 1
+              raise "Invariant: somehow backtracked to beginning of node looking for a comma (node source: #{node_source.inspect})"
+            end
+          end
+
+          end_removal_pos = relative_last_pos
+          cleaned_node_source = node_source[0...begin_removal_pos] + node_source[end_removal_pos..-1]
+          cleaned_node_source
+        end
+      end
+    end
+  end
+end