graphql_cody 1.13.0

data/lib/graphql/rake_task.rb

@@ -0,0 +1,145 @@
+# frozen_string_literal: true
+require "fileutils"
+require "graphql/rake_task/validate"
+
+module GraphQL
+  # A rake task for dumping a schema as IDL or JSON.
+  #
+  # By default, schemas are looked up by name as constants using `schema_name:`.
+  # You can provide a `load_schema` function to return your schema another way.
+  #
+  # `load_context:`, `only:` and `except:` are supported so that
+  # you can keep an eye on how filters affect your schema.
+  #
+  # @example Dump a Schema to .graphql + .json files
+  #   require "graphql/rake_task"
+  #   GraphQL::RakeTask.new(schema_name: "MySchema")
+  #
+  #   # $ rake graphql:schema:dump
+  #   # Schema IDL dumped to ./schema.graphql
+  #   # Schema JSON dumped to ./schema.json
+  #
+  # @example Invoking the task from Ruby
+  #   require "rake"
+  #   Rake::Task["graphql:schema:dump"].invoke
+  class RakeTask
+    include Rake::DSL
+
+    DEFAULT_OPTIONS = {
+      namespace: "graphql",
+      dependencies: nil,
+      schema_name: nil,
+      load_schema: ->(task) { Object.const_get(task.schema_name) },
+      load_context: ->(task) { {} },
+      only: nil,
+      except: nil,
+      directory: ".",
+      idl_outfile: "schema.graphql",
+      json_outfile: "schema.json",
+    }
+
+    # @return [String] Namespace for generated tasks
+    attr_writer :namespace
+
+    def rake_namespace
+      @namespace
+    end
+
+    # @return [Array<String>]
+    attr_accessor :dependencies
+
+    # @return [String] By default, used to find the schema as a constant.
+    # @see {#load_schema} for loading a schema another way
+    attr_accessor :schema_name
+
+    # @return [<#call(task)>] A proc for loading the target GraphQL schema
+    attr_accessor :load_schema
+
+    # @return [<#call(task)>] A callable for loading the query context
+    attr_accessor :load_context
+
+    # @return [<#call(member, ctx)>, nil] A filter for this task
+    attr_accessor :only
+
+    # @return [<#call(member, ctx)>, nil] A filter for this task
+    attr_accessor :except
+
+    # @return [String] target for IDL task
+    attr_accessor :idl_outfile
+
+    # @return [String] target for JSON task
+    attr_accessor :json_outfile
+
+    # @return [String] directory for IDL & JSON files
+    attr_accessor :directory
+
+    # Set the parameters of this task by passing keyword arguments
+    # or assigning attributes inside the block
+    def initialize(options = {})
+      all_options = DEFAULT_OPTIONS.merge(options)
+      all_options.each do |k, v|
+        self.public_send("#{k}=", v)
+      end
+
+      if block_given?
+        yield(self)
+      end
+
+      define_task
+    end
+
+    private
+
+    # Use the provided `method_name` to generate a string from the specified schema
+    # then write it to `file`.
+    def write_outfile(method_name, file)
+      schema = @load_schema.call(self)
+      context = @load_context.call(self)
+      result = schema.public_send(method_name, only: @only, except: @except, context: context)
+      dir = File.dirname(file)
+      FileUtils.mkdir_p(dir)
+      if !result.end_with?("\n")
+        result += "\n"
+      end
+      File.write(file, result)
+    end
+
+    def idl_path
+      File.join(@directory, @idl_outfile)
+    end
+
+    def json_path
+      File.join(@directory, @json_outfile)
+    end
+
+    def load_rails_environment_if_defined
+      if Rake::Task.task_defined?('environment')
+        Rake::Task['environment'].invoke
+      end
+    end
+
+    # Use the Rake DSL to add tasks
+    def define_task
+      namespace(@namespace) do
+        namespace("schema") do
+          desc("Dump the schema to IDL in #{idl_path}")
+          task :idl => @dependencies do
+            load_rails_environment_if_defined
+            write_outfile(:to_definition, idl_path)
+            puts "Schema IDL dumped into #{idl_path}"
+          end
+
+          desc("Dump the schema to JSON in #{json_path}")
+          task :json => @dependencies do
+            load_rails_environment_if_defined
+            write_outfile(:to_json, json_path)
+            puts "Schema JSON dumped into #{json_path}"
+          end
+
+          desc("Dump the schema to JSON and IDL")
+          task :dump => [:idl, :json]
+        end
+      end
+    end
+  end
+end

data/lib/graphql/relay/array_connection.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+module GraphQL
+  module Relay
+    class ArrayConnection < BaseConnection
+      def cursor_from_node(item)
+        idx = (after ? index_from_cursor(after) : 0) + sliced_nodes.find_index(item) + 1
+        encode(idx.to_s)
+      end
+
+      def has_next_page
+        if first
+          # There are more items after these items
+          sliced_nodes.count > first
+        elsif GraphQL::Relay::ConnectionType.bidirectional_pagination && before
+          # The original array is longer than the `before` index
+          index_from_cursor(before) < nodes.length + 1
+        else
+          false
+        end
+      end
+
+      def has_previous_page
+        if last
+          # There are items preceding the ones in this result
+          sliced_nodes.count > last
+        elsif GraphQL::Relay::ConnectionType.bidirectional_pagination && after
+          # We've paginated into the Array a bit, there are some behind us
+          index_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
+      def paged_nodes
+        @paged_nodes ||= begin
+          items = sliced_nodes
+
+          items = items.first(first) if first
+          items = items.last(last) if last
+          items = items.first(max_page_size) if max_page_size && !first && !last
+
+          items
+        end
+      end
+
+      # Apply cursors to edges
+      def sliced_nodes
+        @sliced_nodes ||= if before && after
+          nodes[index_from_cursor(after)..index_from_cursor(before)-1] || []
+        elsif before
+          nodes[0..index_from_cursor(before)-2] || []
+        elsif after
+          nodes[index_from_cursor(after)..-1] || []
+        else
+          nodes
+        end
+      end
+
+      def index_from_cursor(cursor)
+        decode(cursor).to_i
+      end
+    end
+
+    BaseConnection.register_connection_implementation(Array, ArrayConnection)
+  end
+end

data/lib/graphql/relay/base_connection.rb

@@ -0,0 +1,189 @@
+# frozen_string_literal: true
+module GraphQL
+  module Relay
+    # Subclasses must implement:
+    #   - {#cursor_from_node}, which returns an opaque cursor for the given item
+    #   - {#sliced_nodes}, which slices by `before` & `after`
+    #   - {#paged_nodes}, which applies `first` & `last` limits
+    #
+    # In a subclass, you have access to
+    #   - {#nodes}, the collection which the connection will wrap
+    #   - {#first}, {#after}, {#last}, {#before} (arguments passed to the field)
+    #   - {#max_page_size} (the specified maximum page size that can be returned from a connection)
+    #
+    class BaseConnection
+      # Just to encode data in the cursor, use something that won't conflict
+      CURSOR_SEPARATOR = "---"
+
+      # Map of collection class names -> connection_classes
+      # eg `{"Array" => ArrayConnection}`
+      CONNECTION_IMPLEMENTATIONS = {}
+
+      class << self
+        # Find a connection implementation suitable for exposing `nodes`
+        #
+        # @param nodes [Object] A collection of nodes (eg, Array, AR::Relation)
+        # @return [subclass of BaseConnection] a connection Class for wrapping `nodes`
+        def connection_for_nodes(nodes)
+          # If it's a new-style connection object, it's already ready to go
+          if nodes.is_a?(GraphQL::Pagination::Connection)
+            return nodes
+          end
+          # Check for class _names_ because classes can be redefined in Rails development
+          nodes.class.ancestors.each do |ancestor|
+            conn_impl = CONNECTION_IMPLEMENTATIONS[ancestor.name]
+            if conn_impl
+              return conn_impl
+            end
+          end
+          # Should have found a connection during the loop:
+          raise("No connection implementation to wrap #{nodes.class} (#{nodes})")
+        end
+
+        # Add `connection_class` as the connection wrapper for `nodes_class`
+        # eg, `RelationConnection` is the implementation for `AR::Relation`
+        # @param nodes_class [Class] A class representing a collection (eg, Array, AR::Relation)
+        # @param connection_class [Class] A class implementing Connection methods
+        def register_connection_implementation(nodes_class, connection_class)
+          CONNECTION_IMPLEMENTATIONS[nodes_class.name] = connection_class
+        end
+      end
+
+      attr_reader :nodes, :arguments, :max_page_size, :parent, :field, :context
+
+      # Make a connection, wrapping `nodes`
+      # @param nodes [Object] The collection of nodes
+      # @param arguments [GraphQL::Query::Arguments] Query arguments
+      # @param field [GraphQL::Field] The underlying field
+      # @param max_page_size [Int] The maximum number of results to return
+      # @param parent [Object] The object which this collection belongs to
+      # @param context [GraphQL::Query::Context] The context from the field being resolved
+      def initialize(nodes, arguments, field: nil, max_page_size: nil, parent: nil, context: nil)
+        GraphQL::Deprecation.warn "GraphQL::Relay::BaseConnection (used for #{self.class}) will be removed from GraphQL-Ruby 2.0, use GraphQL::Pagination::Connections instead: https://graphql-ruby.org/pagination/overview.html"
+
+        deprecated_caller = caller(0, 10).find { |c| !c.include?("lib/graphql") }
+        if deprecated_caller
+          GraphQL::Deprecation.warn "  -> called from #{deprecated_caller}"
+        end
+
+        @context = context
+        @nodes = nodes
+        @arguments = arguments
+        @field = field
+        @parent = parent
+        @encoder = context ? @context.schema.cursor_encoder : GraphQL::Schema::Base64Encoder
+        @max_page_size = max_page_size.nil? && context ? @context.schema.default_max_page_size : max_page_size
+      end
+
+      def encode(data)
+        @encoder.encode(data, nonce: true)
+      end
+
+      def decode(data)
+        @encoder.decode(data, nonce: true)
+      end
+
+      # The value passed as `first:`, if there was one. Negative numbers become `0`.
+      # @return [Integer, nil]
+      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
+
+      # The value passed as `after:`, if there was one
+      # @return [String, nil]
+      def after
+        arguments[:after]
+      end
+
+      # The value passed as `last:`, if there was one. Negative numbers become `0`.
+      # @return [Integer, nil]
+      def last
+        @last ||= limit_pagination_argument(arguments[:last], max_page_size)
+      end
+
+      # The value passed as `before:`, if there was one
+      # @return [String, nil]
+      def before
+        arguments[:before]
+      end
+
+      # These are the nodes to render for this connection,
+      # probably wrapped by {GraphQL::Relay::Edge}
+      def edge_nodes
+        @edge_nodes ||= paged_nodes
+      end
+
+      # Support the `pageInfo` field
+      def page_info
+        self
+      end
+
+      # Used by `pageInfo`
+      def has_next_page
+        !!(first && sliced_nodes.count > first)
+      end
+
+      # Used by `pageInfo`
+      def has_previous_page
+        !!(last && sliced_nodes.count > last)
+      end
+
+      # Used by `pageInfo`
+      def start_cursor
+        if start_node = (respond_to?(:paged_nodes_array, true) ? paged_nodes_array : paged_nodes).first
+          return cursor_from_node(start_node)
+        else
+          return nil
+        end
+      end
+
+      # Used by `pageInfo`
+      def end_cursor
+        if end_node = (respond_to?(:paged_nodes_array, true) ? paged_nodes_array : paged_nodes).last
+          return cursor_from_node(end_node)
+        else
+          return nil
+        end
+      end
+
+      # An opaque operation which returns a connection-specific cursor.
+      def cursor_from_node(object)
+        raise GraphQL::RequiredImplementationMissingError, "must return a cursor for this object/connection pair"
+      end
+
+      def inspect
+        "#<GraphQL::Relay::Connection @parent=#{@parent.inspect} @arguments=#{@arguments.to_h.inspect}>"
+      end
+
+      private
+
+      # @param argument [nil, Integer] `first` or `last`, as provided by the client
+      # @param max_page_size [nil, Integer]
+      # @return [nil, Integer] `nil` if the input was `nil`, otherwise a value between `0` and `max_page_size`
+      def limit_pagination_argument(argument, max_page_size)
+        if argument
+          if argument < 0
+            argument = 0
+          elsif max_page_size && argument > max_page_size
+            argument = max_page_size
+          end
+        end
+        argument
+      end
+
+      def paged_nodes
+        raise GraphQL::RequiredImplementationMissingError, "must return nodes for this connection after paging"
+      end
+
+      def sliced_nodes
+        raise GraphQL::RequiredImplementationMissingError, "must return  all nodes for this connection after chopping off first and last"
+      end
+    end
+  end
+end

data/lib/graphql/relay/connection_instrumentation.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+module GraphQL
+  module Relay
+    # Provided a GraphQL field which returns a collection of nodes,
+    # wrap that field to expose those nodes as a connection.
+    #
+    # The original resolve proc is used to fetch nodes,
+    # then a connection implementation is fetched with {BaseConnection.connection_for_nodes}.
+    module ConnectionInstrumentation
+      def self.default_arguments
+        @default_arguments ||= begin
+          argument_definitions = [
+              ["first", GraphQL::DEPRECATED_INT_TYPE, "Returns the first _n_ elements from the list."],
+              ["after", GraphQL::DEPRECATED_STRING_TYPE, "Returns the elements in the list that come after the specified cursor."],
+              ["last", GraphQL::DEPRECATED_INT_TYPE, "Returns the last _n_ elements from the list."],
+              ["before", GraphQL::DEPRECATED_STRING_TYPE, "Returns the elements in the list that come before the specified cursor."],
+            ]
+
+          argument_definitions.reduce({}) do |memo, arg_defn|
+            argument = GraphQL::Argument.new
+            name, type, description = arg_defn
+            argument.name = name
+            argument.type = type
+            argument.description = description
+            memo[argument.name.to_s] = argument
+            memo
+          end
+        end
+      end
+
+      # Build a connection field from a {GraphQL::Field} by:
+      # - Merging in the default arguments
+      # - Transforming its resolve function to return a connection object
+      def self.instrument(type, field)
+        # Don't apply the wrapper to class-based fields, since they
+        # use Schema::Field::ConnectionFilter
+        if field.connection? && !field.metadata[:type_class]
+          connection_arguments = default_arguments.merge(field.arguments)
+          original_resolve = field.resolve_proc
+          original_lazy_resolve = field.lazy_resolve_proc
+          connection_resolve = GraphQL::Relay::ConnectionResolve.new(field, original_resolve)
+          connection_lazy_resolve = GraphQL::Relay::ConnectionResolve.new(field, original_lazy_resolve)
+          field.redefine(
+            resolve: connection_resolve,
+            lazy_resolve: connection_lazy_resolve,
+            arguments: connection_arguments,
+          )
+        else
+          field
+        end
+      end
+    end
+  end
+end

data/lib/graphql/relay/connection_resolve.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+module GraphQL
+  module Relay
+    class ConnectionResolve
+      def initialize(field, underlying_resolve)
+        @field = field
+        @underlying_resolve = underlying_resolve
+        @max_page_size = field.connection_max_page_size
+      end
+
+      def call(obj, args, ctx)
+        # in a lazy resolve hook, obj is the promise,
+        # get the object that the promise was
+        # originally derived from
+        parent = ctx.object
+
+        nodes = @underlying_resolve.call(obj, args, ctx)
+
+        if nodes.nil? || ctx.schema.lazy?(nodes) || nodes.is_a?(GraphQL::Execution::Execute::Skip) || ctx.wrapped_connection
+          nodes
+        else
+          ctx.wrapped_connection = true
+          build_connection(nodes, args, parent, ctx)
+        end
+      end
+
+      private
+
+      def build_connection(nodes, args, parent, ctx)
+        if nodes.is_a? GraphQL::ExecutionError
+          ctx.add_error(nodes)
+          nil
+        else
+          if parent.is_a?(GraphQL::Schema::Object)
+            parent = parent.object
+          end
+          connection_class = GraphQL::Relay::BaseConnection.connection_for_nodes(nodes)
+          connection_class.new(nodes, args, field: @field, max_page_size: @max_page_size, parent: parent, context: ctx)
+        end
+      end
+    end
+  end
+end

data/lib/graphql/relay/connection_type.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+module GraphQL
+  module Relay
+    # @api deprecated
+    module ConnectionType
+      class << self
+        # @return [Boolean] If true, connection types get a `nodes` shortcut field
+        attr_accessor :default_nodes_field
+        # @return [Boolean] If true, connections check for reverse-direction `has*Page` values
+        attr_accessor :bidirectional_pagination
+      end
+
+      self.default_nodes_field = false
+      self.bidirectional_pagination = false
+
+      # @api deprecated
+      def self.create_type(wrapped_type, edge_type: nil, edge_class: GraphQL::Relay::Edge, nodes_field: ConnectionType.default_nodes_field, &block)
+        custom_edge_class = edge_class
+
+        # Any call that would trigger `wrapped_type.ensure_defined`
+        # must be inside this lazy block, otherwise we get weird
+        # cyclical dependency errors :S
+        ObjectType.deprecated_define do
+          type_name = wrapped_type.is_a?(GraphQL::BaseType) ? wrapped_type.name : wrapped_type.graphql_name
+          edge_type ||= wrapped_type.edge_type
+          name("#{type_name}Connection")
+          description("The connection type for #{type_name}.")
+          field :edges, types[edge_type], "A list of edges.", edge_class: custom_edge_class, property: :edge_nodes
+
+          if nodes_field
+            field :nodes, types[wrapped_type],  "A list of nodes.", property: :edge_nodes
+          end
+
+          field :pageInfo, !PageInfo, "Information to aid in pagination.", property: :page_info
+          relay_node_type(wrapped_type)
+          block && instance_eval(&block)
+        end
+      end
+    end
+  end
+end

data/lib/graphql/relay/edge.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+module GraphQL
+  module Relay
+    # Mostly an internal concern.
+    #
+    # Wraps an object as a `node`, and exposes a connection-specific `cursor`.
+    class Edge
+      attr_reader :node, :connection
+      def initialize(node, connection)
+        @node = node
+        @connection = connection
+      end
+
+      def cursor
+        @cursor ||= connection.cursor_from_node(node)
+      end
+
+      def parent
+        @parent ||= connection.parent
+      end
+
+      def inspect
+        "#<GraphQL::Relay::Edge (#{parent.inspect} => #{node.inspect})>"
+      end
+    end
+  end
+end

data/lib/graphql/relay/edge_type.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+module GraphQL
+  module Relay
+    module EdgeType
+      # @api deprecated
+      def self.create_type(wrapped_type, name: nil, &block)
+        GraphQL::ObjectType.define do
+          type_name = wrapped_type.is_a?(GraphQL::BaseType) ? wrapped_type.name : wrapped_type.graphql_name
+          name("#{type_name}Edge")
+          description "An edge in a connection."
+          field :node, wrapped_type, "The item at the end of the edge."
+          field :cursor, !types.String, "A cursor for use in pagination."
+          relay_node_type(wrapped_type)
+          block && instance_eval(&block)
+        end
+      end
+    end
+  end
+end

data/lib/graphql/relay/edges_instrumentation.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+module GraphQL
+  module Relay
+    module EdgesInstrumentation
+      def self.instrument(type, field)
+        if field.edges?
+          edges_resolve = EdgesResolve.new(edge_class: field.edge_class, resolve: field.resolve_proc)
+          edges_lazy_resolve = EdgesResolve.new(edge_class: field.edge_class, resolve: field.lazy_resolve_proc)
+
+          field.redefine(
+            resolve: edges_resolve,
+            lazy_resolve: edges_lazy_resolve,
+          )
+        else
+          field
+        end
+      end
+
+      class EdgesResolve
+        def initialize(edge_class:, resolve:)
+          @edge_class = edge_class
+          @resolve_proc = resolve
+        end
+
+        # A user's custom Connection may return a lazy object,
+        # if so, handle it later.
+        def call(obj, args, ctx)
+          parent = ctx.object
+          nodes = @resolve_proc.call(obj, args, ctx)
+          if ctx.schema.lazy?(nodes)
+            nodes
+          else
+            nodes.map { |item| item.is_a?(GraphQL::Pagination::Connection::Edge) ? item : @edge_class.new(item, parent) }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/graphql/relay/global_id_resolve.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+module GraphQL
+  module Relay
+    class GlobalIdResolve
+      def initialize(type:)
+        @type = type
+      end
+
+      def call(obj, args, ctx)
+        if obj.is_a?(GraphQL::Schema::Object)
+          obj = obj.object
+        end
+        type = @type.respond_to?(:graphql_definition) ? @type.graphql_definition : @type
+        ctx.query.schema.id_from_object(obj, type, ctx)
+      end
+    end
+  end
+end