graphql 0.16.0 → 2.0.15

data/lib/graphql/rake_task/validate.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+module GraphQL
+  class RakeTask
+    extend Rake::DSL
+
+    desc "Get the checksum of a graphql-pro version and compare it to published versions on GitHub and graphql-ruby.org"
+    task "graphql:pro:validate", [:gem_version] do |t, args|
+      version = args[:gem_version]
+      if version.nil?
+        raise ArgumentError, "A specific version is required, eg `rake graphql:pro:validate[1.12.0]`"
+      end
+      check = "\e[32m✓\e[0m"
+      ex = "\e[31m✘\e[0m"
+      puts "Validating graphql-pro v#{version}"
+      puts "  - Checking for graphql-pro credentials..."
+
+      creds = `bundle config gems.graphql.pro --parseable`[/[a-z0-9]{11}:[a-z0-9]{11}/]
+      if creds.nil?
+        puts "    #{ex} failed, please set with `bundle config gems.graphql.pro $MY_CREDENTIALS`"
+        exit(1)
+      else
+        puts "    #{check} found"
+      end
+
+      puts "  - Fetching the gem..."
+      fetch_result = `gem fetch graphql-pro -v #{version} --source https://#{creds}@gems.graphql.pro`
+      if fetch_result.empty?
+        puts "    #{ex} failed to fetch v#{version}"
+        exit(1)
+      else
+        puts "    #{check} fetched"
+      end
+
+      puts "  - Validating digest..."
+      require "digest/sha2"
+      gem_digest = Digest::SHA512.new.hexdigest(File.read("graphql-pro-#{version}.gem"))
+      require "net/http"
+      github_uri = URI("https://raw.githubusercontent.com/rmosolgo/graphql-ruby/master/guides/pro/checksums/graphql-pro-#{version}.txt")
+      # Remove final newline from .txt file
+      github_digest = Net::HTTP.get(github_uri).chomp
+
+      docs_uri = URI("https://graphql-ruby.org/pro/checksums/graphql-pro-#{version}.txt")
+      docs_digest = Net::HTTP.get(docs_uri).chomp
+
+      if docs_digest == gem_digest && github_digest == gem_digest
+        puts "    #{check} validated from GitHub"
+        puts "    #{check} validated from graphql-ruby.org"
+      else
+        puts "    #{ex} SHA mismatch:"
+        puts "      Downloaded:       #{gem_digest}"
+        puts "      GitHub:           #{github_digest}"
+        puts "      graphql-ruby.org: #{docs_digest}"
+        puts ""
+        puts "      This download of graphql-pro is invalid, please open an issue:"
+        puts "      https://github.com/rmosolgo/graphql-ruby/issues/new?title=graphql-pro%20digest%20mismatch%20(#{version})"
+        exit(1)
+      end
+
+      puts "\e[32m✔\e[0m graphql-pro #{version} validated successfully!"
+    end
+  end
+end

data/lib/graphql/rake_task.rb

@@ -0,0 +1,146 @@
+# frozen_string_literal: true
+require "fileutils"
+require "rake"
+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/range_add.rb

@@ -0,0 +1,52 @@
+# 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 context [GraphQL::Query::Context] The surrounding `ctx`, will be passed to the connection
+      # @param parent [Object] The owner of `collection`, will be passed to the connection if provided
+      # @param edge_class [Class] The class to wrap `item` with (defaults to the connection's edge class)
+      def initialize(collection:, item:, context:, parent: nil, edge_class: nil)
+        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
+
+        @parent = parent
+      end
+    end
+  end
+end

data/lib/graphql/relay.rb

@@ -0,0 +1,3 @@
+# frozen_string_literal: true
+
+require 'graphql/relay/range_add'

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

data/lib/graphql/rubocop/graphql/default_null_true.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+require_relative "base_cop"
+
+module GraphQL
+  module Rubocop
+    module GraphQL
+      # Identify (and auto-correct) any field configuration which duplicates
+      # the default `null: true` property.
+      #
+      # `null: true` is default because nullable fields can always be converted
+      # to non-null fields (`null: false`) without a breaking change. (The opposite change, from `null: false`
+      # to `null: true`, change.)
+      #
+      # @example
+      #   # Both of these define `name: String` in GraphQL:
+      #
+      #   # bad
+      #   field :name, String, null: true
+      #
+      #   # good
+      #   field :name, String
+      #
+      class DefaultNullTrue < BaseCop
+        MSG = "`null: true` is the default and can be removed."
+
+        def_node_matcher :field_config_with_null_true?, <<-Pattern
+        (
+          send nil? :field ... (hash $(pair (sym :null) (true)) ...)
+        )
+        Pattern
+
+        def on_send(node)
+          field_config_with_null_true?(node) do |null_config|
+            add_offense(null_config) do |corrector|
+              cleaned_node_source = source_without_keyword_argument(node, null_config)
+              corrector.replace(node.source_range, cleaned_node_source)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/graphql/rubocop/graphql/default_required_true.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+require_relative "./base_cop"
+
+module GraphQL
+  module Rubocop
+    module GraphQL
+      # Identify (and auto-correct) any argument configuration which duplicates
+      # the default `required: true` property.
+      #
+      # `required: true` is default because required arguments can always be converted
+      # to optional arguments (`required: false`) without a breaking change. (The opposite change, from `required: false`
+      # to `required: true`, change.)
+      #
+      # @example
+      #   # Both of these define `id: ID!` in GraphQL:
+      #
+      #   # bad
+      #   argument :id, ID, required: true
+      #
+      #   # good
+      #   argument :id, ID
+      #
+      class DefaultRequiredTrue < BaseCop
+        MSG = "`required: true` is the default and can be removed."
+
+        def_node_matcher :argument_config_with_required_true?, <<-Pattern
+        (
+          send {nil? _} :argument ... (hash <$(pair (sym :required) (true)) ...>)
+        )
+        Pattern
+
+        def on_send(node)
+          argument_config_with_required_true?(node) do |required_config|
+            add_offense(required_config) do |corrector|
+              cleaned_node_source = source_without_keyword_argument(node, required_config)
+              corrector.replace(node, cleaned_node_source)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/graphql/rubocop.rb

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+
+require "graphql/rubocop/graphql/default_null_true"
+require "graphql/rubocop/graphql/default_required_true"

data/lib/graphql/runtime_type_error.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+module GraphQL
+  class RuntimeTypeError < GraphQL::Error
+  end
+end

data/lib/graphql/schema/addition.rb

@@ -0,0 +1,245 @@
+# frozen_string_literal: true
+
+module GraphQL
+  class Schema
+    class Addition
+      attr_reader :directives, :possible_types, :types, :union_memberships, :references, :arguments_with_default_values
+
+      def initialize(schema:, own_types:, new_types:)
+        @schema = schema
+        @own_types = own_types
+        @directives = Set.new
+        @possible_types = {}
+        @types = {}
+        @union_memberships = {}
+        @references = Hash.new { |h, k| h[k] = [] }
+        @arguments_with_default_values = []
+        add_type_and_traverse(new_types)
+      end
+
+      private
+
+      def references_to(thing, from:)
+        @references[thing] << from
+      end
+
+      def get_type(name)
+        local_type = @types[name]
+        # This isn't really sophisticated, but
+        # I think it's good enough to support the current usage of LateBoundTypes
+        if local_type.is_a?(Array)
+          local_type = local_type.first
+        end
+        local_type || @schema.get_type(name)
+      end
+
+      # Lookup using `own_types` here because it's ok to override
+      # inherited types by name
+      def get_local_type(name)
+        @types[name] || @own_types[name]
+      end
+
+      def add_directives_from(owner)
+        dirs = owner.directives.map(&:class)
+        @directives.merge(dirs)
+        add_type_and_traverse(dirs)
+      end
+
+      def add_type_and_traverse(new_types)
+        late_types = []
+        new_types.each { |t| add_type(t, owner: nil, late_types: late_types, path: [t.graphql_name]) }
+        missed_late_types = 0
+        while (late_type_vals = late_types.shift)
+          type_owner, lt = late_type_vals
+          if lt.is_a?(String)
+            type = Member::BuildType.constantize(lt)
+            # Reset the counter, since we might succeed next go-round
+            missed_late_types = 0
+            update_type_owner(type_owner, type)
+            add_type(type, owner: type_owner, late_types: late_types, path: [type.graphql_name])
+          elsif lt.is_a?(LateBoundType)
+            if (type = get_type(lt.name))
+              # Reset the counter, since we might succeed next go-round
+              missed_late_types = 0
+              update_type_owner(type_owner, type)
+              add_type(type, owner: type_owner, late_types: late_types, path: [type.graphql_name])
+            else
+              missed_late_types += 1
+              # Add it back to the list, maybe we'll be able to resolve it later.
+              late_types << [type_owner, lt]
+              if missed_late_types == late_types.size
+                # We've looked at all of them and haven't resolved one.
+                raise UnresolvedLateBoundTypeError.new(type: lt)
+              else
+                # Try the next one
+              end
+            end
+          else
+            raise ArgumentError, "Unexpected late type: #{lt.inspect}"
+          end
+        end
+        nil
+      end
+
+      def update_type_owner(owner, type)
+        case owner
+        when Module
+          if owner.kind.union?
+            # It's a union with possible_types
+            # Replace the item by class name
+            owner.assign_type_membership_object_type(type)
+            @possible_types[owner.graphql_name] = owner.possible_types
+          elsif type.kind.interface? && (owner.kind.object? || owner.kind.interface?)
+            new_interfaces = []
+            owner.interfaces.each do |int_t|
+              if int_t.is_a?(String) && int_t == type.graphql_name
+                new_interfaces << type
+              elsif int_t.is_a?(LateBoundType) && int_t.graphql_name == type.graphql_name
+                new_interfaces << type
+              else
+                # Don't re-add proper interface definitions,
+                # they were probably already added, maybe with options.
+              end
+            end
+            owner.implements(*new_interfaces)
+            new_interfaces.each do |int|
+              pt = @possible_types[int.graphql_name] ||= []
+              if !pt.include?(owner) && owner.is_a?(Class)
+                pt << owner
+              end
+              int.interfaces.each do |indirect_int|
+                if indirect_int.is_a?(LateBoundType) && (indirect_int_type = get_type(indirect_int.graphql_name))
+                  update_type_owner(owner, indirect_int_type)
+                end
+              end
+            end
+          end
+        when nil
+          # It's a root type
+          @types[type.graphql_name] = type
+        when GraphQL::Schema::Field, GraphQL::Schema::Argument
+          orig_type = owner.type
+          # Apply list/non-null wrapper as needed
+          if orig_type.respond_to?(:of_type)
+            transforms = []
+            while (orig_type.respond_to?(:of_type))
+              if orig_type.kind.non_null?
+                transforms << :to_non_null_type
+              elsif orig_type.kind.list?
+                transforms << :to_list_type
+              else
+                raise "Invariant: :of_type isn't non-null or list"
+              end
+              orig_type = orig_type.of_type
+            end
+            transforms.reverse_each { |t| type = type.public_send(t) }
+          end
+          owner.type = type
+        else
+          raise "Unexpected update: #{owner.inspect} #{type.inspect}"
+        end
+      end
+
+      def add_type(type, owner:, late_types:, path:)
+        if type.is_a?(String) || type.is_a?(GraphQL::Schema::LateBoundType)
+          late_types << [owner, type]
+          return
+        end
+
+        if owner.is_a?(Class) && owner < GraphQL::Schema::Union
+          um = @union_memberships[type.graphql_name] ||= []
+          um << owner
+        end
+
+        if (prev_type = get_local_type(type.graphql_name)) && (prev_type == type || (prev_type.is_a?(Array) && prev_type.include?(type)))
+          # No need to re-visit
+        elsif type.is_a?(Class) && type < GraphQL::Schema::Directive
+          @directives << type
+          type.all_argument_definitions.each do |arg|
+            arg_type = arg.type.unwrap
+            references_to(arg_type, from: arg)
+            add_type(arg_type, owner: arg, late_types: late_types, path: path + [arg.graphql_name])
+            if arg.default_value?
+              @arguments_with_default_values << arg
+            end
+          end
+        else
+          prev_type = @types[type.graphql_name]
+          if prev_type.nil?
+            @types[type.graphql_name] = type
+          elsif prev_type.is_a?(Array)
+            prev_type << type
+          else
+            @types[type.graphql_name] = [prev_type, type]
+          end
+
+          add_directives_from(type)
+          if type.kind.fields?
+            type.all_field_definitions.each do |field|
+              name = field.graphql_name
+              field_type = field.type.unwrap
+              references_to(field_type, from: field)
+              field_path = path + [name]
+              add_type(field_type, owner: field, late_types: late_types, path: field_path)
+              add_directives_from(field)
+              field.all_argument_definitions.each do |arg|
+                add_directives_from(arg)
+                arg_type = arg.type.unwrap
+                references_to(arg_type, from: arg)
+                add_type(arg_type, owner: arg, late_types: late_types, path: field_path + [arg.graphql_name])
+                if arg.default_value?
+                  @arguments_with_default_values << arg
+                end
+              end
+            end
+          end
+          if type.kind.input_object?
+            type.all_argument_definitions.each do |arg|
+              add_directives_from(arg)
+              arg_type = arg.type.unwrap
+              references_to(arg_type, from: arg)
+              add_type(arg_type, owner: arg, late_types: late_types, path: path + [arg.graphql_name])
+              if arg.default_value?
+                @arguments_with_default_values << arg
+              end
+            end
+          end
+          if type.kind.union?
+            @possible_types[type.graphql_name] = type.all_possible_types
+            type.all_possible_types.each do |t|
+              add_type(t, owner: type, late_types: late_types, path: path + ["possible_types"])
+            end
+          end
+          if type.kind.interface?
+            type.orphan_types.each do |t|
+              add_type(t, owner: type, late_types: late_types, path: path + ["orphan_types"])
+            end
+          end
+          if type.kind.object?
+            possible_types_for_this_name = @possible_types[type.graphql_name] ||= []
+            possible_types_for_this_name << type
+          end
+
+          if type.kind.object? || type.kind.interface?
+            type.interface_type_memberships.each do |interface_type_membership|
+              case interface_type_membership
+              when Schema::TypeMembership
+                interface_type = interface_type_membership.abstract_type
+                # We can get these now; we'll have to get late-bound types later
+                if interface_type.is_a?(Module) && type.is_a?(Class)
+                  implementers = @possible_types[interface_type.graphql_name] ||= []
+                  implementers << type
+                end
+              when String, Schema::LateBoundType
+                interface_type = interface_type_membership
+              else
+                raise ArgumentError, "Invariant: unexpected type membership for #{type.graphql_name}: #{interface_type_membership.class} (#{interface_type_membership.inspect})"
+              end
+              add_type(interface_type, owner: type, late_types: late_types, path: path + ["implements"])
+            end
+          end
+        end
+      end
+    end
+  end
+end