graphql 1.13.3 → 1.13.7

data/lib/generators/graphql/type_generator.rb

@@ -8,13 +8,28 @@ require_relative 'core'
 
 module Graphql
   module Generators
-    class TypeGeneratorBase < Rails::Generators::Base
+    class TypeGeneratorBase < Rails::Generators::NamedBase
       include Core
 
-      argument :type_name,
-        type: :string,
-        banner: "TypeName",
-        desc: "Name of this object type (expressed as Ruby or GraphQL)"
+      class_option 'namespaced_types',
+        type: :boolean,
+        required: false,
+        default: false,
+        banner: "Namespaced",
+        desc: "If the generated types will be namespaced"
+
+      argument :custom_fields,
+                type: :array,
+                default: [],
+                banner: "name:type name:type ...",
+                desc: "Fields for this object (type may be expressed as Ruby or GraphQL)"
+
+      
+      attr_accessor :graphql_type
+
+      def create_type_file
+        template "#{graphql_type}.erb", "#{options[:directory]}/types#{subdirectory}/#{type_file_name}.rb"
+      end
 
       # Take a type expression in any combination of GraphQL or Ruby styles
       # and return it in a specified output style
@@ -60,12 +75,12 @@ module Graphql
 
       # @return [String] The user-provided type name, normalized to Ruby code
       def type_ruby_name
-        @type_ruby_name ||= self.class.normalize_type_expression(type_name, mode: :ruby)[0]
+        @type_ruby_name ||= self.class.normalize_type_expression(name, mode: :ruby)[0]
       end
 
       # @return [String] The user-provided type name, as a GraphQL name
       def type_graphql_name
-        @type_graphql_name ||= self.class.normalize_type_expression(type_name, mode: :graphql)[0]
+        @type_graphql_name ||= self.class.normalize_type_expression(name, mode: :graphql)[0]
       end
 
       # @return [String] The user-provided type name, as a file name (without extension)
@@ -82,6 +97,24 @@ module Graphql
         }
       end
 
+      def ruby_class_name
+        class_prefix = 
+          if options[:namespaced_types]
+            "#{graphql_type.pluralize.camelize}::"
+          else
+            ""
+          end
+        @ruby_class_name || class_prefix + type_ruby_name.sub(/^Types::/, "")
+      end
+
+      def subdirectory
+        if options[:namespaced_types]
+          "/#{graphql_type.pluralize}"
+        else
+          ""
+        end
+      end
+
       class NormalizedField
         def initialize(name, type_expr, null)
           @name = name
@@ -89,8 +122,12 @@ module Graphql
           @null = null
         end
 
-        def to_ruby
-          "field :#{@name}, #{@type_expr}, null: #{@null}"
+        def to_object_field
+          "field :#{@name}, #{@type_expr}#{@null ? '' : ', null: false'}"
+        end
+
+        def to_input_argument
+          "argument :#{@name}, #{@type_expr}, required: false"
         end
       end
     end

data/lib/generators/graphql/union_generator.rb

@@ -19,14 +19,14 @@ module Graphql
         banner: "type type ...",
         desc: "Possible types for this union (expressed as Ruby or GraphQL)"
 
-      def create_type_file
-        template "union.erb", "#{options[:directory]}/types/#{type_file_name}.rb"
-      end
-
       private
 
+      def graphql_type
+        "union"
+      end
+
       def normalized_possible_types
-        possible_types.map { |t| self.class.normalize_type_expression(t, mode: :ruby)[0] }
+        custom_fields.map { |t| self.class.normalize_type_expression(t, mode: :ruby)[0] }
       end
     end
   end

data/lib/graphql/analysis/ast/visitor.rb

@@ -100,7 +100,8 @@ module GraphQL
         def on_field(node, parent)
           @response_path.push(node.alias || node.name)
           parent_type = @object_types.last
-          field_definition = @schema.get_field(parent_type, node.name, @query.context)
+          # This could be nil if the previous field wasn't found:
+          field_definition = parent_type && @schema.get_field(parent_type, node.name, @query.context)
           @field_definitions.push(field_definition)
           if !field_definition.nil?
             next_object_type = field_definition.type.unwrap

data/lib/graphql/dataloader/source.rb

@@ -138,8 +138,8 @@ module GraphQL
       # @api private
       def result_for(key)
         if !@results.key?(key)
-          raise <<-ERR
-Invariant: fetching result for a key on #{self.class} that hasn't been loaded yet (#{key.inspect}, loaded: #{@results.keys})
+          raise GraphQL::InvariantError, <<-ERR
+Fetching result for a key on #{self.class} that hasn't been loaded yet (#{key.inspect}, loaded: #{@results.keys})
 
 This key should have been loaded already. This is a bug in GraphQL::Dataloader, please report it on GitHub: https://github.com/rmosolgo/graphql-ruby/issues/new.
 ERR

data/lib/graphql/date_encoding_error.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+module GraphQL
+  # This error is raised when `Types::ISO8601Date` is asked to return a value
+  # that cannot be parsed to a Ruby Date.
+  #
+  # @see GraphQL::Types::ISO8601Date which raises this error
+  class DateEncodingError < GraphQL::RuntimeTypeError
+    # The value which couldn't be encoded
+    attr_reader :date_value
+
+    def initialize(value)
+      @date_value = value
+      super("Date cannot be parsed: #{value}. \nDate must be be able to be parsed as a Ruby Date object.")
+    end
+  end
+end

data/lib/graphql/execution/interpreter/arguments_cache.rb

@@ -31,8 +31,10 @@ module GraphQL
           # If any jobs were enqueued, run them now,
           # since this might have been called outside of execution.
           # (The jobs are responsible for updating `result` in-place.)
-          @dataloader.run_isolated do
-            @storage[ast_node][argument_owner][parent_object]
+          if !@storage.key?(ast_node) || !@storage[ast_node].key?(argument_owner)
+            @dataloader.run_isolated do
+              @storage[ast_node][argument_owner][parent_object]
+            end
           end
           # Ack, the _hash_ is updated, but the key is eventually
           # overridden with an immutable arguments instance.

data/lib/graphql/execution/interpreter/runtime.rb

@@ -159,7 +159,8 @@ module GraphQL
           # Identify runtime directives by checking which of this schema's directives have overridden `def self.resolve`
           @runtime_directive_names = []
           noop_resolve_owner = GraphQL::Schema::Directive.singleton_class
-          schema.directives.each do |name, dir_defn|
+          @schema_directives = schema.directives
+          @schema_directives.each do |name, dir_defn|
             if dir_defn.method(:resolve).owner != noop_resolve_owner
               @runtime_directive_names << name
             end
@@ -206,7 +207,7 @@ module GraphQL
             # Root .authorized? returned false.
             @response = nil
           else
-            resolve_with_directives(object_proxy, root_operation.directives) do # execute query level directives
+            call_method_on_directives(:resolve, object_proxy, root_operation.directives) do # execute query level directives
               gathered_selections = gather_selections(object_proxy, root_type, root_operation.selections)
               # This is kind of a hack -- `gathered_selections` is an Array if any of the selections
               # require isolation during execution (because of runtime directives). In that case,
@@ -226,7 +227,7 @@ module GraphQL
 
                 @dataloader.append_job {
                   set_all_interpreter_context(query.root_value, nil, nil, path)
-                  resolve_with_directives(object_proxy, selections.graphql_directives) do
+                  call_method_on_directives(:resolve, object_proxy, selections.graphql_directives) do
                     evaluate_selections(
                       path,
                       context.scoped_context,
@@ -502,7 +503,7 @@ module GraphQL
               }
             end
 
-            field_result = resolve_with_directives(object, directives) do
+            field_result = call_method_on_directives(:resolve, object, directives) do
               # Actually call the field resolver and capture the result
               app_result = begin
                 query.with_error_handling do
@@ -734,7 +735,7 @@ module GraphQL
                     final_result = nil
                   end
                   set_all_interpreter_context(continue_value, nil, nil, path) # reset this mutable state
-                  resolve_with_directives(continue_value, selections.graphql_directives) do
+                  call_method_on_directives(:resolve, continue_value, selections.graphql_directives) do
                     evaluate_selections(
                       path,
                       context.scoped_context,
@@ -753,6 +754,8 @@ module GraphQL
             end
           when "LIST"
             inner_type = current_type.of_type
+            # This is true for objects, unions, and interfaces
+            use_dataloader_job = !inner_type.unwrap.kind.input?
             response_list = GraphQLResultArray.new(result_name, selection_result)
             response_list.graphql_non_null_list_items = inner_type.non_null?
             set_result(selection_result, result_name, response_list)
@@ -767,12 +770,12 @@ module GraphQL
                 this_idx = idx
                 next_path.freeze
                 idx += 1
-                # This will update `response_list` with the lazy
-                after_lazy(inner_value, owner: inner_type, path: next_path, ast_node: ast_node, scoped_context: scoped_context, field: field, owner_object: owner_object, arguments: arguments, result_name: this_idx, result: response_list) do |inner_inner_value|
-                  continue_value = continue_value(next_path, inner_inner_value, owner_type, field, inner_type.non_null?, ast_node, this_idx, response_list)
-                  if HALT != continue_value
-                    continue_field(next_path, continue_value, owner_type, field, inner_type, ast_node, next_selections, false, owner_object, arguments, this_idx, response_list)
+                if use_dataloader_job
+                  @dataloader.append_job do
+                    resolve_list_item(inner_value, inner_type, next_path, ast_node, scoped_context, field, owner_object, arguments, this_idx, response_list, next_selections, owner_type)
                   end
+                else
+                  resolve_list_item(inner_value, inner_type, next_path, ast_node, scoped_context, field, owner_object, arguments, this_idx, response_list, next_selections, owner_type)
                 end
               end
             rescue NoMethodError => err
@@ -792,17 +795,30 @@ module GraphQL
           end
         end
 
-        def resolve_with_directives(object, directives, &block)
+        def resolve_list_item(inner_value, inner_type, next_path, ast_node, scoped_context, field, owner_object, arguments, this_idx, response_list, next_selections, owner_type) # rubocop:disable Metrics/ParameterLists
+          set_all_interpreter_context(nil, nil, nil, next_path)
+          call_method_on_directives(:resolve_each, owner_object, ast_node.directives) do
+            # This will update `response_list` with the lazy
+            after_lazy(inner_value, owner: inner_type, path: next_path, ast_node: ast_node, scoped_context: scoped_context, field: field, owner_object: owner_object, arguments: arguments, result_name: this_idx, result: response_list) do |inner_inner_value|
+              continue_value = continue_value(next_path, inner_inner_value, owner_type, field, inner_type.non_null?, ast_node, this_idx, response_list)
+              if HALT != continue_value
+                continue_field(next_path, continue_value, owner_type, field, inner_type, ast_node, next_selections, false, owner_object, arguments, this_idx, response_list)
+              end
+            end
+          end
+        end
+
+        def call_method_on_directives(method_name, object, directives, &block)
           return yield if directives.nil? || directives.empty?
-          run_directive(object, directives, 0, &block)
+          run_directive(method_name, object, directives, 0, &block)
         end
 
-        def run_directive(object, directives, idx, &block)
+        def run_directive(method_name, object, directives, idx, &block)
           dir_node = directives[idx]
           if !dir_node
             yield
           else
-            dir_defn = schema.directives.fetch(dir_node.name)
+            dir_defn = @schema_directives.fetch(dir_node.name)
             if !dir_defn.is_a?(Class)
               dir_defn = dir_defn.type_class || raise("Only class-based directives are supported (not `@#{dir_node.name}`)")
             end
@@ -821,8 +837,8 @@ module GraphQL
             if dir_args == HALT
               nil
             else
-              dir_defn.resolve(object, dir_args, context) do
-                run_directive(object, directives, idx + 1, &block)
+              dir_defn.public_send(method_name, object, dir_args, context) do
+                run_directive(method_name, object, directives, idx + 1, &block)
               end
             end
           end
@@ -831,7 +847,7 @@ module GraphQL
         # Check {Schema::Directive.include?} for each directive that's present
         def directives_include?(node, graphql_object, parent_type)
           node.directives.each do |dir_node|
-            dir_defn = schema.directives.fetch(dir_node.name).type_class || raise("Only class-based directives are supported (not #{dir_node.name.inspect})")
+            dir_defn = @schema_directives.fetch(dir_node.name).type_class || raise("Only class-based directives are supported (not #{dir_node.name.inspect})")
             args = arguments(graphql_object, dir_defn, dir_node)
             if !dir_defn.include?(graphql_object, args, context)
               return false

data/lib/graphql/introspection/directive_location_enum.rb

@@ -6,8 +6,8 @@ module GraphQL
       description "A Directive can be adjacent to many parts of the GraphQL language, "\
                   "a __DirectiveLocation describes one such possible adjacencies."
 
-      GraphQL::Directive::LOCATIONS.each do |location|
-        value(location.to_s, GraphQL::Directive::LOCATION_DESCRIPTIONS[location], value: location)
+      GraphQL::Schema::Directive::LOCATIONS.each do |location|
+        value(location.to_s, GraphQL::Schema::Directive::LOCATION_DESCRIPTIONS[location], value: location)
       end
       introspection true
     end

data/lib/graphql/introspection/directive_type.rb

@@ -19,6 +19,8 @@ module GraphQL
       field :on_fragment, Boolean, null: false, deprecation_reason: "Use `locations`.", method: :on_fragment?
       field :on_field, Boolean, null: false, deprecation_reason: "Use `locations`.", method: :on_field?
 
+      field :is_repeatable, Boolean, method: :repeatable?
+
       def args(include_deprecated:)
         args = @context.warden.arguments(@object)
         args = args.reject(&:deprecation_reason) unless include_deprecated

data/lib/graphql/introspection/schema_type.rb

@@ -13,6 +13,11 @@ module GraphQL
       field :mutation_type, GraphQL::Schema::LateBoundType.new("__Type"), "If this server supports mutation, the type that mutation operations will be rooted at."
       field :subscription_type, GraphQL::Schema::LateBoundType.new("__Type"), "If this server support subscription, the type that subscription operations will be rooted at."
       field :directives, [GraphQL::Schema::LateBoundType.new("__Directive")], "A list of all directives supported by this server.", null: false
+      field :description, String, resolver_method: :schema_description
+
+      def schema_description
+        context.schema.description
+      end
 
       def types
         @context.warden.reachable_types.sort_by(&:graphql_name)

data/lib/graphql/introspection/type_type.rb

@@ -12,7 +12,7 @@ module GraphQL
                   "possible at runtime. List and NonNull types compose other types."
 
       field :kind, GraphQL::Schema::LateBoundType.new("__TypeKind"), null: false
-      field :name, String
+      field :name, String, method: :graphql_name
       field :description, String
       field :fields, [GraphQL::Schema::LateBoundType.new("__Field")] do
         argument :include_deprecated, Boolean, required: false, default_value: false
@@ -27,8 +27,14 @@ module GraphQL
       end
       field :of_type, GraphQL::Schema::LateBoundType.new("__Type")
 
-      def name
-        object.graphql_name
+      field :specified_by_url, String
+
+      def specified_by_url
+        if object.kind.scalar?
+          object.specified_by_url
+        else
+          nil
+        end
       end
 
       def kind

data/lib/graphql/introspection.rb

@@ -7,6 +7,7 @@ module GraphQL
       <<-QUERY
 query IntrospectionQuery {
   __schema {
+    description
     queryType { name }
     mutationType { name }
     subscriptionType { name }
@@ -17,6 +18,7 @@ query IntrospectionQuery {
       name
       description
       locations
+      isRepeatable
       args#{include_deprecated_args ? '(includeDeprecated: true)' : ''} {
         ...InputValue
       }
@@ -27,6 +29,7 @@ fragment FullType on __Type {
   kind
   name
   description
+  specifiedByUrl
   fields(includeDeprecated: true) {
     name
     description

data/lib/graphql/language/document_from_schema_definition.rb

@@ -152,6 +152,7 @@ module GraphQL
       def build_directive_node(directive)
         GraphQL::Language::Nodes::DirectiveDefinition.new(
           name: directive.graphql_name,
+          repeatable: directive.repeatable?,
           arguments: build_argument_nodes(warden.arguments(directive)),
           locations: build_directive_location_nodes(directive.locations),
           description: directive.description,