graphql 1.9.5 → 1.13.19

data/lib/graphql/upgrader/member.rb

@@ -13,7 +13,7 @@ module GraphQL
       # @param input_text [String] Untransformed GraphQL-Ruby code
       # @return [String] The input text, with a transformation applied if necessary
       def apply(input_text)
-        raise NotImplementedError, "Return transformed text here"
+        raise GraphQL::RequiredImplementationMissingError, "Return transformed text here"
       end
 
       # Recursively transform a `.define`-DSL-based type expression into a class-ready expression, for example:
@@ -125,7 +125,7 @@ module GraphQL
       end
 
       def apply(input_text)
-        input_text.sub(@find_pattern, @replace_pattern)
+        input_text.gsub(@find_pattern, @replace_pattern)
       end
     end
 
@@ -147,10 +147,10 @@ module GraphQL
             name = matches[:overridden_name]
             if type_name_without_the_type_part != name
               # If the overridden name is still required, use `graphql_name` for it
-              transformable = transformable.sub(/ name (.*)/, ' graphql_name \1')
+              transformable = transformable.gsub(/ name (.*)/, ' graphql_name \1')
             else
               # Otherwise, remove it altogether
-              transformable = transformable.sub(/\s+name ('|").*('|")/, '')
+              transformable = transformable.gsub(/\s+name ('|").*('|")/, '')
             end
           end
         end
@@ -285,43 +285,57 @@ module GraphQL
       def apply(input_text)
         if input_text =~ @proc_check_pattern
           processor = apply_processor(input_text, NamedProcProcessor.new(@proc_name))
-          proc_body = input_text[processor.proc_body_start..processor.proc_body_end]
-          method_defn_indent = " " * processor.proc_defn_indent
-          method_defn = "def self.#{@proc_name}(#{processor.proc_arg_names.join(", ")})\n#{method_defn_indent}  #{proc_body}\n#{method_defn_indent}end\n"
-          method_defn = trim_lines(method_defn)
-          # replace the proc with the new method
-          input_text[processor.proc_defn_start..processor.proc_defn_end] = method_defn
+          processor.proc_to_method_sections.reverse.each do |proc_to_method_section|
+            proc_body = input_text[proc_to_method_section.proc_body_start..proc_to_method_section.proc_body_end]
+            method_defn_indent = " " * proc_to_method_section.proc_defn_indent
+            method_defn = "def self.#{@proc_name}(#{proc_to_method_section.proc_arg_names.join(", ")})\n#{method_defn_indent}  #{proc_body}\n#{method_defn_indent}end\n"
+            method_defn = trim_lines(method_defn)
+            # replace the proc with the new method
+            input_text[proc_to_method_section.proc_defn_start..proc_to_method_section.proc_defn_end] = method_defn
+          end
         end
         input_text
       end
 
       class NamedProcProcessor < Parser::AST::Processor
-        attr_reader :proc_arg_names, :proc_defn_start, :proc_defn_end, :proc_defn_indent, :proc_body_start, :proc_body_end
+        attr_reader :proc_to_method_sections
         def initialize(proc_name)
           @proc_name_sym = proc_name.to_sym
-          @proc_arg_names = nil
-          # Beginning of the `#{proc_name} -> {...}` call
-          @proc_defn_start = nil
-          # End of the last `end/}`
-          @proc_defn_end = nil
-          # Amount of whitespace to insert to the rewritten body
-          @proc_defn_indent = nil
-          # First statement of the proc
-          @proc_body_start = nil
-          # End of last statement in the proc
-          @proc_body_end = nil
-          # Used for identifying the proper block
-          @inside_proc = false
+          @proc_to_method_sections = []
+        end
+
+        class ProcToMethodSection
+          attr_accessor :proc_arg_names, :proc_defn_start, :proc_defn_end, :proc_defn_indent, :proc_body_start, :proc_body_end, :inside_proc
+
+          def initialize
+            # @proc_name_sym = proc_name.to_sym
+            @proc_arg_names = nil
+            # Beginning of the `#{proc_name} -> {...}` call
+            @proc_defn_start = nil
+            # End of the last `end/}`
+            @proc_defn_end = nil
+            # Amount of whitespace to insert to the rewritten body
+            @proc_defn_indent = nil
+            # First statement of the proc
+            @proc_body_start = nil
+            # End of last statement in the proc
+            @proc_body_end = nil
+            # Used for identifying the proper block
+            @inside_proc = false
+          end
         end
 
         def on_send(node)
           receiver, method_name, _args = *node
           if method_name == @proc_name_sym && receiver.nil?
+            proc_section = ProcToMethodSection.new
             source_exp = node.loc.expression
-            @proc_defn_start = source_exp.begin.begin_pos
-            @proc_defn_end = source_exp.end.end_pos
-            @proc_defn_indent = source_exp.column
-            @inside_proc = true
+            proc_section.proc_defn_start = source_exp.begin.begin_pos
+            proc_section.proc_defn_end = source_exp.end.end_pos
+            proc_section.proc_defn_indent = source_exp.column
+            proc_section.inside_proc = true
+
+            @proc_to_method_sections << proc_section
           end
           res = super(node)
           @inside_proc = false
@@ -331,11 +345,14 @@ module GraphQL
         def on_block(node)
           send_node, args_node, body_node = node.children
           _receiver, method_name, _send_args_node = *send_node
-          if method_name == :lambda && @inside_proc
+          if method_name == :lambda && !@proc_to_method_sections.empty? && @proc_to_method_sections[-1].inside_proc
+            proc_to_method_section = @proc_to_method_sections[-1]
+
             source_exp = body_node.loc.expression
-            @proc_arg_names = args_node.children.map { |arg_node| arg_node.children[0].to_s }
-            @proc_body_start = source_exp.begin.begin_pos
-            @proc_body_end = source_exp.end.end_pos
+            proc_to_method_section.proc_arg_names = args_node.children.map { |arg_node| arg_node.children[0].to_s }
+            proc_to_method_section.proc_body_start = source_exp.begin.begin_pos
+            proc_to_method_section.proc_body_end = source_exp.end.end_pos
+            proc_to_method_section.inside_proc = false
           end
           super(node)
         end
@@ -353,30 +370,34 @@ module GraphQL
         if input_text =~ /GraphQL::Relay::Mutation\.define/
           named_proc_processor = apply_processor(input_text, ProcToClassMethodTransform::NamedProcProcessor.new(@proc_name))
           resolve_proc_processor = apply_processor(input_text, ResolveProcToMethodTransform::ResolveProcProcessor.new)
-          proc_body = input_text[named_proc_processor.proc_body_start..named_proc_processor.proc_body_end]
-          method_defn_indent = " " * named_proc_processor.proc_defn_indent
-
-          obj_arg_name, args_arg_name, ctx_arg_name = resolve_proc_processor.proc_arg_names
-          # This is not good, it will hit false positives
-          # Should use AST to make this substitution
-          if obj_arg_name != "_"
-            proc_body.gsub!(/([^\w:.]|^)#{obj_arg_name}([^\w:]|$)/, '\1object\2')
-          end
-          if ctx_arg_name != "_"
-            proc_body.gsub!(/([^\w:.]|^)#{ctx_arg_name}([^\w:]|$)/, '\1context\2')
-          end
 
-          method_defn = "def #{@proc_name}(**#{args_arg_name})\n#{method_defn_indent}  #{proc_body}\n#{method_defn_indent}end\n"
-          method_defn = trim_lines(method_defn)
-          # Update usage of args keys
-          method_defn = method_defn.gsub(/#{args_arg_name}(?<method_begin>\.key\?\(?|\[)["':](?<arg_name>[a-zA-Z0-9_]+)["']?(?<method_end>\]|\))?/) do
-            method_begin = $~[:method_begin]
-            arg_name = underscorize($~[:arg_name])
-            method_end = $~[:method_end]
-            "#{args_arg_name}#{method_begin}:#{arg_name}#{method_end}"
+          named_proc_processor.proc_to_method_sections.zip(resolve_proc_processor.resolve_proc_sections).reverse.each do |pair|
+            proc_to_method_section, resolve_proc_section = *pair
+            proc_body = input_text[proc_to_method_section.proc_body_start..proc_to_method_section.proc_body_end]
+            method_defn_indent = " " * proc_to_method_section.proc_defn_indent
+
+            obj_arg_name, args_arg_name, ctx_arg_name = resolve_proc_section.proc_arg_names
+            # This is not good, it will hit false positives
+            # Should use AST to make this substitution
+            if obj_arg_name != "_"
+              proc_body.gsub!(/([^\w:.]|^)#{obj_arg_name}([^\w:]|$)/, '\1object\2')
+            end
+            if ctx_arg_name != "_"
+              proc_body.gsub!(/([^\w:.]|^)#{ctx_arg_name}([^\w:]|$)/, '\1context\2')
+            end
+
+            method_defn = "def #{@proc_name}(**#{args_arg_name})\n#{method_defn_indent}  #{proc_body}\n#{method_defn_indent}end\n"
+            method_defn = trim_lines(method_defn)
+            # Update usage of args keys
+            method_defn = method_defn.gsub(/#{args_arg_name}(?<method_begin>\.key\?\(?|\[)["':](?<arg_name>[a-zA-Z0-9_]+)["']?(?<method_end>\]|\))?/) do
+              method_begin = $~[:method_begin]
+              arg_name = underscorize($~[:arg_name])
+              method_end = $~[:method_end]
+              "#{args_arg_name}#{method_begin}:#{arg_name}#{method_end}"
+            end
+            # replace the proc with the new method
+            input_text[proc_to_method_section.proc_defn_start..proc_to_method_section.proc_defn_end] = method_defn
           end
-          # replace the proc with the new method
-          input_text[named_proc_processor.proc_defn_start..named_proc_processor.proc_defn_end] = method_defn
         end
         input_text
       end
@@ -512,74 +533,86 @@ module GraphQL
           input_text.match(/(?<field_type>input_field|field|connection|argument) :(?<name>[a-zA-Z_0-9_]*)/)
           field_name = $~[:name]
           processor = apply_processor(input_text, ResolveProcProcessor.new)
-          proc_body = input_text[processor.proc_start..processor.proc_end]
-          obj_arg_name, args_arg_name, ctx_arg_name = processor.proc_arg_names
-          # This is not good, it will hit false positives
-          # Should use AST to make this substitution
-          if obj_arg_name != "_"
-            proc_body.gsub!(/([^\w:.]|^)#{obj_arg_name}([^\w:]|$)/, '\1object\2')
-          end
-          if ctx_arg_name != "_"
-            proc_body.gsub!(/([^\w:.]|^)#{ctx_arg_name}([^\w:]|$)/, '\1context\2')
-          end
 
-          method_def_indent = " " * (processor.resolve_indent - 2)
-          # Turn the proc body into a method body
-          method_body = reindent_lines(proc_body, from_indent: processor.resolve_indent + 2, to_indent: processor.resolve_indent)
-          # Add `def... end`
-          method_def = if input_text.include?("argument ")
-            # This field has arguments
-            "def #{field_name}(**#{args_arg_name})"
-          else
-            # No field arguments, so, no method arguments
-            "def #{field_name}"
-          end
-          # Wrap the body in def ... end
-          method_body = "\n#{method_def_indent}#{method_def}\n#{method_body}\n#{method_def_indent}end\n"
-          # Update Argument access to be underscore and symbols
-          # Update `args[...]` and `args.key?`
-          method_body = method_body.gsub(/#{args_arg_name}(?<method_begin>\.key\?\(?|\[)["':](?<arg_name>[a-zA-Z0-9_]+)["']?(?<method_end>\]|\))?/) do
-            method_begin = $~[:method_begin]
-            arg_name = underscorize($~[:arg_name])
-            method_end = $~[:method_end]
-            "#{args_arg_name}#{method_begin}:#{arg_name}#{method_end}"
-          end
+          processor.resolve_proc_sections.reverse.each do |resolve_proc_section|
+            proc_body = input_text[resolve_proc_section.proc_start..resolve_proc_section.proc_end]
+            obj_arg_name, args_arg_name, ctx_arg_name = resolve_proc_section.proc_arg_names
+            # This is not good, it will hit false positives
+            # Should use AST to make this substitution
+            if obj_arg_name != "_"
+              proc_body.gsub!(/([^\w:.]|^)#{obj_arg_name}([^\w:]|$)/, '\1object\2')
+            end
+            if ctx_arg_name != "_"
+              proc_body.gsub!(/([^\w:.]|^)#{ctx_arg_name}([^\w:]|$)/, '\1context\2')
+            end
+
+            method_def_indent = " " * (resolve_proc_section.resolve_indent - 2)
+            # Turn the proc body into a method body
+            method_body = reindent_lines(proc_body, from_indent: resolve_proc_section.resolve_indent + 2, to_indent: resolve_proc_section.resolve_indent)
+            # Add `def... end`
+            method_def = if input_text.include?("argument ")
+              # This field has arguments
+              "def #{field_name}(**#{args_arg_name})"
+            else
+              # No field arguments, so, no method arguments
+              "def #{field_name}"
+            end
+            # Wrap the body in def ... end
+            method_body = "\n#{method_def_indent}#{method_def}\n#{method_body}\n#{method_def_indent}end\n"
+            # Update Argument access to be underscore and symbols
+            # Update `args[...]` and `args.key?`
+            method_body = method_body.gsub(/#{args_arg_name}(?<method_begin>\.key\?\(?|\[)["':](?<arg_name>[a-zA-Z0-9_]+)["']?(?<method_end>\]|\))?/) do
+              method_begin = $~[:method_begin]
+              arg_name = underscorize($~[:arg_name])
+              method_end = $~[:method_end]
+              "#{args_arg_name}#{method_begin}:#{arg_name}#{method_end}"
+            end
 
-          # Replace the resolve proc with the method
-          input_text[processor.resolve_start..processor.resolve_end] = ""
-          # The replacement above might have left some preceeding whitespace,
-          # so remove it by deleting all whitespace chars before `resolve`:
-          preceeding_whitespace = processor.resolve_start - 1
-          while input_text[preceeding_whitespace] == " " && preceeding_whitespace > 0
-            input_text[preceeding_whitespace] = ""
-            preceeding_whitespace -= 1
+            # Replace the resolve proc with the method
+            input_text[resolve_proc_section.resolve_start..resolve_proc_section.resolve_end] = ""
+            # The replacement above might have left some preceeding whitespace,
+            # so remove it by deleting all whitespace chars before `resolve`:
+            preceeding_whitespace = resolve_proc_section.resolve_start - 1
+            while input_text[preceeding_whitespace] == " " && preceeding_whitespace > 0
+              input_text[preceeding_whitespace] = ""
+              preceeding_whitespace -= 1
+            end
+            input_text += method_body
+            input_text
           end
-          input_text += method_body
-          input_text
-        else
-          # No resolve proc
-          input_text
         end
+
+        input_text
       end
 
       class ResolveProcProcessor < Parser::AST::Processor
-        attr_reader :proc_start, :proc_end, :proc_arg_names, :resolve_start, :resolve_end, :resolve_indent
+        attr_reader :resolve_proc_sections
         def initialize
-          @proc_arg_names = nil
-          @resolve_start = nil
-          @resolve_end = nil
-          @resolve_indent = nil
-          @proc_start = nil
-          @proc_end = nil
+          @resolve_proc_sections = []
+        end
+
+        class ResolveProcSection
+          attr_accessor :proc_start, :proc_end, :proc_arg_names, :resolve_start, :resolve_end, :resolve_indent
+          def initialize
+            @proc_arg_names = nil
+            @resolve_start = nil
+            @resolve_end = nil
+            @resolve_indent = nil
+            @proc_start = nil
+            @proc_end = nil
+          end
         end
 
         def on_send(node)
           receiver, method_name, _args = *node
           if method_name == :resolve && receiver.nil?
+            resolve_proc_section = ResolveProcSection.new
             source_exp = node.loc.expression
-            @resolve_start = source_exp.begin.begin_pos
-            @resolve_end = source_exp.end.end_pos
-            @resolve_indent = source_exp.column
+            resolve_proc_section.resolve_start = source_exp.begin.begin_pos
+            resolve_proc_section.resolve_end = source_exp.end.end_pos
+            resolve_proc_section.resolve_indent = source_exp.column
+
+            @resolve_proc_sections << resolve_proc_section
           end
           super(node)
         end
@@ -588,11 +621,15 @@ module GraphQL
           send_node, args_node, body_node = node.children
           _receiver, method_name, _send_args_node = *send_node
           # Assume that the first three-argument proc we enter is the resolve
-          if method_name == :lambda && args_node.children.size == 3 && @proc_arg_names.nil?
+          if (
+            method_name == :lambda && args_node.children.size == 3 &&
+            !@resolve_proc_sections.empty? && @resolve_proc_sections[-1].proc_arg_names.nil?
+          )
+            resolve_proc_section = @resolve_proc_sections[-1]
             source_exp = body_node.loc.expression
-            @proc_arg_names = args_node.children.map { |arg_node| arg_node.children[0].to_s }
-            @proc_start = source_exp.begin.begin_pos
-            @proc_end = source_exp.end.end_pos
+            resolve_proc_section.proc_arg_names = args_node.children.map { |arg_node| arg_node.children[0].to_s }
+            resolve_proc_section.proc_start = source_exp.begin.begin_pos
+            resolve_proc_section.proc_end = source_exp.end.end_pos
           end
           super(node)
         end
@@ -734,6 +771,7 @@ module GraphQL
 
     class Member
       def initialize(member, skip: SkipOnNullKeyword, type_transforms: DEFAULT_TYPE_TRANSFORMS, field_transforms: DEFAULT_FIELD_TRANSFORMS, clean_up_transforms: DEFAULT_CLEAN_UP_TRANSFORMS)
+        GraphQL::Deprecation.warn "#{self.class} will be removed from GraphQL-Ruby 2.0 (but there's no point in using it after you've transformed your code, anyways)"
         @member = member
         @skip = skip
         @type_transforms = type_transforms

data/lib/graphql/upgrader/schema.rb

@@ -4,6 +4,7 @@ module GraphQL
   module Upgrader
     class Schema
       def initialize(schema)
+        GraphQL::Deprecation.warn "#{self.class} will be removed from GraphQL-Ruby 2.0 (but there's no point in using it after you've transformed your code, anyways)"
         @schema = schema
       end
 

data/lib/graphql/version.rb

@@ -1,4 +1,4 @@
 # frozen_string_literal: true
 module GraphQL
-  VERSION = "1.9.5"
+  VERSION = "1.13.19"
 end

data/lib/graphql.rb

@@ -4,12 +4,41 @@ require "json"
 require "set"
 require "singleton"
 require "forwardable"
-require_relative "./graphql/railtie" if defined? Rails::Railtie
 
 module GraphQL
+  # forwards-compat for argument handling
+  module Ruby2Keywords
+    if RUBY_VERSION < "2.7"
+      def ruby2_keywords(*)
+      end
+    end
+  end
+
   class Error < StandardError
   end
 
+  # This error is raised when GraphQL-Ruby encounters a situation
+  # that it *thought* would never happen. Please report this bug!
+  class InvariantError < Error
+    def initialize(message)
+      message += "
+
+This is probably a bug in GraphQL-Ruby, please report this error on GitHub: https://github.com/rmosolgo/graphql-ruby/issues/new?template=bug_report.md"
+      super(message)
+    end
+  end
+
+  class RequiredImplementationMissingError < Error
+  end
+
+  class << self
+    def default_parser
+      @default_parser ||= GraphQL::Language::Parser
+    end
+
+    attr_writer :default_parser
+  end
+
   # Turn a query string or schema definition into an AST
   # @param graphql_string [String] a GraphQL query string or schema definition
   # @return [GraphQL::Language::Nodes::Document]
@@ -42,10 +71,21 @@ end
 # Order matters for these:
 
 require "graphql/execution_error"
+require "graphql/runtime_type_error"
+require "graphql/unresolved_type_error"
+require "graphql/invalid_null_error"
+require "graphql/analysis_error"
+require "graphql/coercion_error"
+require "graphql/invalid_name_error"
+require "graphql/integer_decoding_error"
+require "graphql/integer_encoding_error"
+require "graphql/string_encoding_error"
+require "graphql/date_encoding_error"
+
 require "graphql/define"
+require "graphql/deprecation"
 require "graphql/base_type"
 require "graphql/object_type"
-
 require "graphql/enum_type"
 require "graphql/input_object_type"
 require "graphql/interface_type"
@@ -63,15 +103,23 @@ require "graphql/scalar_type"
 require "graphql/name_validator"
 
 require "graphql/language"
+
+require_relative "./graphql/railtie" if defined? Rails::Railtie
+
 require "graphql/analysis"
 require "graphql/tracing"
-require "graphql/execution"
 require "graphql/dig"
+require "graphql/execution"
+require "graphql/pagination"
 require "graphql/schema"
+require "graphql/query"
+require "graphql/types"
+require "graphql/dataloader"
+require "graphql/filter"
+require "graphql/internal_representation"
 require "graphql/directive"
+require "graphql/static_validation"
 require "graphql/execution"
-require "graphql/types"
-require "graphql/relay"
 require "graphql/boolean_type"
 require "graphql/float_type"
 require "graphql/id_type"
@@ -81,23 +129,11 @@ require "graphql/schema/built_in_types"
 require "graphql/schema/loader"
 require "graphql/schema/printer"
 require "graphql/introspection"
+require "graphql/relay"
 
-require "graphql/analysis_error"
-require "graphql/coercion_error"
-require "graphql/literal_validation_error"
-require "graphql/runtime_type_error"
-require "graphql/invalid_null_error"
-require "graphql/invalid_name_error"
-require "graphql/unresolved_type_error"
-require "graphql/integer_encoding_error"
-require "graphql/string_encoding_error"
-require "graphql/query"
-require "graphql/internal_representation"
-require "graphql/static_validation"
 require "graphql/version"
 require "graphql/compatibility"
 require "graphql/function"
-require "graphql/filter"
 require "graphql/subscriptions"
 require "graphql/parse_error"
 require "graphql/backtrace"
@@ -107,3 +143,38 @@ require "graphql/authorization"
 require "graphql/unauthorized_error"
 require "graphql/unauthorized_field_error"
 require "graphql/load_application_object_failed_error"
+require "graphql/directive/include_directive"
+require "graphql/directive/skip_directive"
+require "graphql/directive/deprecated_directive"
+
+module GraphQL
+  # Ruby has `deprecate_constant`,
+  # but I don't see a way to give a nice error message in that case,
+  # so I'm doing this instead.
+  DEPRECATED_INT_TYPE = INT_TYPE
+  DEPRECATED_FLOAT_TYPE = FLOAT_TYPE
+  DEPRECATED_STRING_TYPE = STRING_TYPE
+  DEPRECATED_BOOLEAN_TYPE = BOOLEAN_TYPE
+  DEPRECATED_ID_TYPE = ID_TYPE
+
+  remove_const :INT_TYPE
+  remove_const :FLOAT_TYPE
+  remove_const :STRING_TYPE
+  remove_const :BOOLEAN_TYPE
+  remove_const :ID_TYPE
+
+  def self.const_missing(const_name)
+    deprecated_const_name = :"DEPRECATED_#{const_name}"
+    if const_defined?(deprecated_const_name)
+      deprecated_type = const_get(deprecated_const_name)
+      deprecated_caller = caller(1, 1).first
+      # Don't warn about internal uses, like `types.Int`
+      if !deprecated_caller.include?("lib/graphql")
+        warn "GraphQL::#{const_name} is deprecated and will be removed in GraphQL-Ruby 2.0, use GraphQL::Types::#{deprecated_type.graphql_name} instead. (from #{deprecated_caller})"
+      end
+      deprecated_type
+    else
+      super
+    end
+  end
+end

data/readme.md

@@ -1,15 +1,12 @@
 # graphql <img src="https://cloud.githubusercontent.com/assets/2231765/9094460/cb43861e-3b66-11e5-9fbf-71066ff3ab13.png" height="40" alt="graphql-ruby"/>
 
-[![Build Status](https://travis-ci.org/rmosolgo/graphql-ruby.svg?branch=master)](https://travis-ci.org/rmosolgo/graphql-ruby)
+[![CI Suite](https://github.com/rmosolgo/graphql-ruby/actions/workflows/ci.yaml/badge.svg)](https://github.com/rmosolgo/graphql-ruby/actions/workflows/ci.yaml)
 [![Gem Version](https://badge.fury.io/rb/graphql.svg)](https://rubygems.org/gems/graphql)
-[![Code Climate](https://codeclimate.com/github/rmosolgo/graphql-ruby/badges/gpa.svg)](https://codeclimate.com/github/rmosolgo/graphql-ruby)
-[![Test Coverage](https://codeclimate.com/github/rmosolgo/graphql-ruby/badges/coverage.svg)](https://codeclimate.com/github/rmosolgo/graphql-ruby)
-[![built with love](https://cloud.githubusercontent.com/assets/2231765/6766607/d07992c6-cfc9-11e4-813f-d9240714dd50.png)](https://rmosolgo.github.io/react-badges/)
 
 A Ruby implementation of [GraphQL](https://graphql.org/).
 
 - [Website](https://graphql-ruby.org/)
-- [API Documentation](https://www.rubydoc.info/gems/graphql)
+- [API Documentation](https://www.rubydoc.info/github/rmosolgo/graphql-ruby)
 - [Newsletter](https://tinyletter.com/graphql-ruby)
 
 ## Installation
@@ -33,7 +30,7 @@ $ rails generate graphql:install
 
 After this, you may need to run `bundle install` again, as by default graphiql-rails is added on installation.
 
-Or, see ["Getting Started"](https://graphql-ruby.org/).
+Or, see ["Getting Started"](https://graphql-ruby.org/getting_started.html).
 
 ## Upgrade
 
@@ -47,6 +44,6 @@ I also sell [GraphQL::Pro](https://graphql.pro) which provides several features
 
 ## Getting Involved
 
-- __Say hi & ask questions__ in the [#ruby channel on Slack](https://graphql-slack.herokuapp.com/) or [on Twitter](https://twitter.com/rmosolgo)!
+- __Say hi & ask questions__ in the #graphql-ruby channel on [Discord](https://discord.com/invite/xud7bH9) or [on Twitter](https://twitter.com/rmosolgo)!
 - __Report bugs__ by posting a description, full stack trace, and all relevant code in a  [GitHub issue](https://github.com/rmosolgo/graphql-ruby/issues).
 - __Start hacking__ with the [Development guide](https://graphql-ruby.org/development).