graphql 1.11.6 → 1.13.19

data/lib/generators/graphql/templates/graphql_controller.erb

@@ -15,9 +15,9 @@ class GraphqlController < ApplicationController
     }
     result = <%= schema_name %>.execute(query, variables: variables, context: context, operation_name: operation_name)
     render json: result
-  rescue => e
+  rescue StandardError => e
     raise e unless Rails.env.development?
-    handle_error_in_development e
+    handle_error_in_development(e)
   end
 
   private

data/lib/generators/graphql/templates/input.erb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+<% module_namespacing_when_supported do -%>
+module Types
+  class <%= ruby_class_name %> < Types::BaseInputObject
+<% normalized_fields.each do |f| %>    <%= f.to_input_argument %>
+<% end %>  end
+end
+<% end -%>

data/lib/generators/graphql/templates/interface.erb

@@ -1,8 +1,10 @@
+# frozen_string_literal: true
+
 <% module_namespacing_when_supported do -%>
 module Types
-  module <%= type_ruby_name.split('::')[-1] %>
+  module <%= ruby_class_name %>
     include Types::BaseInterface
-<% normalized_fields.each do |f| %>    <%= f.to_ruby %>
+<% normalized_fields.each do |f| %>    <%= f.to_object_field %>
 <% end %>  end
 end
 <% end -%>

data/lib/generators/graphql/templates/mutation.erb

@@ -1,6 +1,6 @@
 <% module_namespacing_when_supported do -%>
 module Mutations
-  class <%= mutation_name %> < BaseMutation
+  class <%= class_name %> < BaseMutation
     # TODO: define return fields
     # field :post, Types::PostType, null: false
 

data/lib/generators/graphql/templates/mutation_create.erb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+<% module_namespacing_when_supported do -%>
+module Mutations
+  class <%= class_name %>Create < BaseMutation
+    description "Creates a new <%= file_name %>"
+
+    field :<%= file_name %>, Types::<%= options[:namespaced_types] ? 'Objects::' : '' %><%= class_name %>Type, null: false
+
+    argument :<%= file_name %>_input, Types::<%= options[:namespaced_types] ? 'Inputs::' : '' %><%= class_name %>InputType, required: true
+
+    def resolve(<%= file_name %>_input:)
+      <%= singular_table_name %> = ::<%= orm_class.build(class_name, "**#{file_name}_input") %>
+      raise GraphQL::ExecutionError.new "Error creating <%= file_name %>", extensions: <%= singular_table_name %>.errors.to_hash unless <%= orm_instance.save %>
+
+      { <%= file_name %>: <%= singular_table_name %> }
+    end
+  end
+end
+<% end -%>

data/lib/generators/graphql/templates/mutation_delete.erb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+<% module_namespacing_when_supported do -%>
+module Mutations
+  class <%= class_name %>Delete < BaseMutation
+    description "Deletes a <%= file_name %> by ID"
+
+    field :<%= file_name %>, Types::<%= options[:namespaced_types] ? 'Objects::' : '' %><%= class_name %>Type, null: false
+
+    argument :id, ID, required: true
+
+    def resolve(id:)
+      <%= singular_table_name %> = ::<%= orm_class.find(class_name, "id") %>
+      raise GraphQL::ExecutionError.new "Error deleting <%= file_name %>", extensions: <%= singular_table_name %>.errors.to_hash unless <%= orm_instance.destroy %>
+
+      { <%= file_name %>: <%= singular_table_name %> }
+    end
+  end
+end
+<% end -%>

data/lib/generators/graphql/templates/mutation_update.erb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+<% module_namespacing_when_supported do -%>
+module Mutations
+  class <%= class_name %>Update < BaseMutation
+    description "Updates a <%= file_name %> by id"
+
+    field :<%= file_name %>, Types::<%= options[:namespaced_types] ? 'Objects::' : '' %><%= class_name %>Type, null: false
+
+    argument :id, ID, required: true
+    argument :<%= file_name %>_input, Types::<%= options[:namespaced_types] ? 'Inputs::' : '' %><%= class_name %>InputType, required: true
+
+    def resolve(id:, <%= file_name %>_input:)
+      <%= singular_table_name %> = ::<%= orm_class.find(class_name, "id") %>
+      raise GraphQL::ExecutionError.new "Error updating <%= file_name %>", extensions: <%= singular_table_name %>.errors.to_hash unless <%= orm_instance.update("**#{file_name}_input") %>
+
+      { <%= file_name %>: <%= singular_table_name %> }
+    end
+  end
+end
+<% end -%>

data/lib/generators/graphql/templates/node_type.erb

@@ -0,0 +1,9 @@
+<% module_namespacing_when_supported do -%>
+module Types
+  module NodeType
+    include Types::BaseInterface
+    # Add the `id` field
+    include GraphQL::Types::Relay::NodeBehaviors
+  end
+end
+<% end -%>

data/lib/generators/graphql/templates/object.erb

@@ -1,8 +1,10 @@
+# frozen_string_literal: true
+
 <% module_namespacing_when_supported do -%>
 module Types
-  class <%= type_ruby_name.split('::')[-1] %> < Types::BaseObject
-<% if options.node %>    implements GraphQL::Relay::Node.interface
-<% end %><% normalized_fields.each do |f| %>    <%= f.to_ruby %>
+  class <%= ruby_class_name %> < Types::BaseObject
+<% if options.node %>    implements GraphQL::Types::Relay::Node
+<% end %><% normalized_fields.each do |f| %>    <%= f.to_object_field %>
 <% end %>  end
 end
 <% end -%>

data/lib/generators/graphql/templates/query_type.erb

@@ -10,8 +10,6 @@ module Types
     def test_field
       "Hello World!"
     end
-<% if options[:relay] %>
-    field :node, field: GraphQL::Relay::Node.field
-<% end %>  end
+  end
 end
 <% end -%>

data/lib/generators/graphql/templates/scalar.erb

@@ -1,6 +1,8 @@
+# frozen_string_literal: true
+
 <% module_namespacing_when_supported do -%>
 module Types
-  class <%= type_ruby_name.split('::')[-1] %> < Types::BaseScalar
+  class <%= ruby_class_name %> < Types::BaseScalar
     def self.coerce_input(input_value, context)
       # Override this to prepare a client-provided GraphQL value for your Ruby code
       input_value

data/lib/generators/graphql/templates/schema.erb

@@ -1,42 +1,27 @@
 <% module_namespacing_when_supported do -%>
 class <%= schema_name %> < GraphQL::Schema
   query(Types::QueryType)
-
-  # Opt in to the new runtime (default in future graphql-ruby versions)
-  use GraphQL::Execution::Interpreter
-  use GraphQL::Analysis::AST
-
-  # Add built-in connections for pagination
-  use GraphQL::Pagination::Connections
-<% if options[:relay] %>
-  # Relay Object Identification:
-
-  # Return a string UUID for `object`
-  def self.id_from_object(object, type_definition, query_ctx)
-    # Here's a simple implementation which:
-    # - joins the type name & object.id
-    # - encodes it with base64:
-    # GraphQL::Schema::UniqueWithinType.encode(type_definition.name, object.id)
-  end
-
-  # Given a string UUID, find the object
-  def self.object_from_id(id, query_ctx)
-    # For example, to decode the UUIDs generated above:
-    # type_name, item_id = GraphQL::Schema::UniqueWithinType.decode(id)
-    #
-    # Then, based on `type_name` and `id`
-    # find an object in your application
-    # ...
+<% if options[:batch] %>
+  # GraphQL::Batch setup:
+  use GraphQL::Batch
+<% else %>
+  # For batch-loading (see https://graphql-ruby.org/dataloader/overview.html)
+  use GraphQL::Dataloader
+<% end %>
+  # GraphQL-Ruby calls this when something goes wrong while running a query:
+  def self.type_error(err, context)
+    # if err.is_a?(GraphQL::InvalidNullError)
+    #   # report to your bug tracker here
+    #   return nil
+    # end
+    super
   end
 
-  # Object Resolution
-  def self.resolve_type(type, obj, ctx)
-    # TODO: Implement this function
-    # to return the correct type for `obj`
+  # Union and Interface Resolution
+  def self.resolve_type(abstract_type, obj, ctx)
+    # TODO: Implement this method
+    # to return the correct GraphQL object type for `obj`
     raise(GraphQL::RequiredImplementationMissingError)
   end
-<% end %><% if options[:batch] %>
-  # GraphQL::Batch setup:
-  use GraphQL::Batch
-<% end %>end
+end
 <% end -%>

data/lib/generators/graphql/templates/union.erb

@@ -1,7 +1,9 @@
+# frozen_string_literal: true
+
 <% module_namespacing_when_supported do -%>
 module Types
-  class <%= type_ruby_name.split('::')[-1] %> < Types::BaseUnion
-<% if possible_types.any? %>    possible_types <%= normalized_possible_types.join(", ") %>
+  class <%= ruby_class_name %> < Types::BaseUnion
+<% if custom_fields.any? %>    possible_types <%= normalized_possible_types.join(", ") %>
 <% end %>  end
 end
 <% end -%>

data/lib/generators/graphql/type_generator.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+require 'rails/generators'
 require 'rails/generators/base'
 require 'graphql'
 require 'active_support'
@@ -7,14 +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,
-        required: true,
-        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/analyze_query.rb

@@ -3,6 +3,11 @@ module GraphQL
   module Analysis
     module_function
 
+    def use(schema_class)
+      schema = schema_class.is_a?(Class) ? schema_class : schema_class.target
+      schema.analysis_engine = self
+    end
+
     # @return [void]
     def analyze_multiplex(multiplex, analyzers)
       multiplex.trace("analyze_multiplex", { multiplex: multiplex }) do
@@ -38,6 +43,8 @@ module GraphQL
     # @param analyzers [Array<#call>] Objects that respond to `#call(memo, visit_type, irep_node)`
     # @return [Array<Any>] Results from those analyzers
     def analyze_query(query, analyzers, multiplex_states: [])
+      GraphQL::Deprecation.warn "Legacy analysis will be removed in GraphQL-Ruby 2.0, please upgrade to AST Analysis: https://graphql-ruby.org/queries/ast_analysis.html (schema: #{query.schema})"
+
       query.trace("analyze_query", { query: query }) do
         analyzers_to_run = analyzers.select do |analyzer|
           if analyzer.respond_to?(:analyze?)

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

@@ -7,6 +7,7 @@ module GraphQL
           super
           @used_fields = Set.new
           @used_deprecated_fields = Set.new
+          @used_deprecated_arguments = Set.new
         end
 
         def on_leave_field(node, parent, visitor)
@@ -14,14 +15,40 @@ module GraphQL
           field = "#{visitor.parent_type_definition.graphql_name}.#{field_defn.graphql_name}"
           @used_fields << field
           @used_deprecated_fields << field if field_defn.deprecation_reason
+          arguments = visitor.query.arguments_for(node, visitor.field_definition)
+          # If there was an error when preparing this argument object,
+          # then this might be an error or something:
+          if arguments.respond_to?(:argument_values)
+            extract_deprecated_arguments(arguments.argument_values)
+          end
         end
 
         def result
           {
             used_fields: @used_fields.to_a,
-            used_deprecated_fields: @used_deprecated_fields.to_a
+            used_deprecated_fields: @used_deprecated_fields.to_a,
+            used_deprecated_arguments: @used_deprecated_arguments.to_a,
           }
         end
+
+        private
+
+        def extract_deprecated_arguments(argument_values)
+          argument_values.each_pair do |_argument_name, argument|
+            if argument.definition.deprecation_reason
+              @used_deprecated_arguments << argument.definition.path
+            end
+
+            if argument.definition.type.kind.input_object?
+              extract_deprecated_arguments(argument.value.arguments.argument_values) # rubocop:disable Development/ContextIsPassedCop -- runtime args instance
+            elsif argument.definition.type.list? && !argument.value.nil?
+              argument
+                .value
+                .select { |value| value.respond_to?(:arguments) }
+                .each { |value| extract_deprecated_arguments(value.arguments.argument_values) } # rubocop:disable Development/ContextIsPassedCop -- runtime args instance
+            end
+          end
+        end
       end
     end
   end

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

@@ -23,18 +23,22 @@ module GraphQL
 
           attr_reader :field_definition, :response_path, :query
 
-          # @param node [Language::Nodes::Field] The AST node; used for providing argument values when necessary
+          # @param parent_type [Class] The owner of `field_definition`
           # @param field_definition [GraphQL::Field, GraphQL::Schema::Field] Used for getting the `.complexity` configuration
           # @param query [GraphQL::Query] Used for `query.possible_types`
           # @param response_path [Array<String>] The path to the response key for the field
-          def initialize(node, field_definition, query, response_path)
-            @node = node
+          def initialize(parent_type, field_definition, query, response_path)
+            @parent_type = parent_type
             @field_definition = field_definition
             @query = query
             @response_path = response_path
             @scoped_children = nil
+            @nodes = []
           end
 
+          # @return [Array<GraphQL::Language::Nodes::Field>]
+          attr_reader :nodes
+
           # Returns true if this field has no selections, ie, it's a scalar.
           # We need a quick way to check whether we should continue traversing.
           def terminal?
@@ -50,16 +54,7 @@ module GraphQL
           end
 
           def own_complexity(child_complexity)
-            defined_complexity = @field_definition.complexity
-            case defined_complexity
-            when Proc
-              arguments = @query.arguments_for(@node, @field_definition)
-              defined_complexity.call(@query.context, arguments.keyword_arguments, child_complexity)
-            when Numeric
-              defined_complexity + child_complexity
-            else
-              raise("Invalid complexity: #{defined_complexity.inspect} on #{@field_definition.name}")
-            end
+            @field_definition.calculate_complexity(query: @query, nodes: @nodes, child_complexity: child_complexity)
           end
         end
 
@@ -79,7 +74,8 @@ module GraphQL
           # then the query would have been rejected as invalid.
           complexities_on_type = @complexities_on_type_by_query[visitor.query] ||= [ScopedTypeComplexity.new(nil, nil, query, visitor.response_path)]
 
-          complexity = complexities_on_type.last.scoped_children[parent_type][field_key] ||= ScopedTypeComplexity.new(node, visitor.field_definition, visitor.query, visitor.response_path)
+          complexity = complexities_on_type.last.scoped_children[parent_type][field_key] ||= ScopedTypeComplexity.new(parent_type, visitor.field_definition, visitor.query, visitor.response_path)
+          complexity.nodes.push(node)
           # Push it on the stack.
           complexities_on_type.push(complexity)
         end

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

@@ -19,6 +19,7 @@ module GraphQL
           @field_definitions = []
           @argument_definitions = []
           @directive_definitions = []
+          @rescued_errors = []
           @query = query
           @schema = query.schema
           @response_path = []
@@ -32,6 +33,9 @@ module GraphQL
         # @return [Array<GraphQL::ObjectType>] Types whose scope we've entered
         attr_reader :object_types
 
+        # @return [Array<GraphQL::AnalysisError]
+        attr_reader :rescued_errors
+
         def visit
           return unless @document
           super
@@ -96,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)
+          # 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
@@ -134,14 +139,14 @@ module GraphQL
           argument_defn = if (arg = @argument_definitions.last)
             arg_type = arg.type.unwrap
             if arg_type.kind.input_object?
-              arg_type.arguments[node.name]
+              arg_type.get_argument(node.name, @query.context)
             else
               nil
             end
           elsif (directive_defn = @directive_definitions.last)
-            directive_defn.arguments[node.name]
+            directive_defn.get_argument(node.name, @query.context)
           elsif (field_defn = @field_definitions.last)
-            field_defn.arguments[node.name]
+            field_defn.get_argument(node.name, @query.context)
           else
             nil
           end
@@ -239,7 +244,11 @@ module GraphQL
 
         def call_analyzers(method, node, parent)
           @analyzers.each do |analyzer|
-            analyzer.public_send(method, node, parent, self)
+            begin
+              analyzer.public_send(method, node, parent, self)
+            rescue AnalysisError => err
+              @rescued_errors << err
+            end
           end
         end
 

data/lib/graphql/analysis/ast.rb

@@ -13,7 +13,12 @@ module GraphQL
       module_function
 
       def use(schema_class)
-        schema_class.analysis_engine = GraphQL::Analysis::AST
+        if schema_class.analysis_engine == self
+          definition_line = caller(2, 1).first
+          GraphQL::Deprecation.warn("GraphQL::Analysis::AST is now the default; remove `use GraphQL::Analysis::AST` from the schema definition (#{definition_line})")
+        else
+          schema_class.analysis_engine = self
+        end
       end
 
       # Analyze a multiplex, and all queries within.
@@ -67,7 +72,11 @@ module GraphQL
 
             visitor.visit
 
-            query_analyzers.map(&:result)
+            if visitor.rescued_errors.any?
+              visitor.rescued_errors
+            else
+              query_analyzers.map(&:result)
+            end
           else
             []
           end

data/lib/graphql/argument.rb

@@ -3,7 +3,7 @@ module GraphQL
   # @api deprecated
   class Argument
     include GraphQL::Define::InstanceDefinable
-    accepts_definitions :name, :type, :description, :default_value, :as, :prepare, :method_access, :deprecation_reason
+    deprecated_accepts_definitions :name, :type, :description, :default_value, :as, :prepare, :method_access, :deprecation_reason
     attr_reader :default_value
     attr_accessor :description, :name, :as, :deprecation_reason
     attr_accessor :ast_node

data/lib/graphql/backtrace/inspect_result.rb

@@ -1,5 +1,4 @@
 # frozen_string_literal: true
-# test_via: ../backtrace.rb
 module GraphQL
   class Backtrace
     module InspectResult

data/lib/graphql/backtrace/legacy_tracer.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+module GraphQL
+  class Backtrace
+    module LegacyTracer
+      module_function
+
+      # Implement the {GraphQL::Tracing} API.
+      def trace(key, metadata)
+        case key
+        when "lex", "parse"
+          # No context here, don't have a query yet
+          nil
+        when "execute_multiplex", "analyze_multiplex"
+          # No query context yet
+          nil
+        when "validate", "analyze_query", "execute_query", "execute_query_lazy"
+          query = metadata[:query] || metadata[:queries].first
+          push_data = query
+          multiplex = query.multiplex
+        when "execute_field", "execute_field_lazy"
+          # The interpreter passes `query:`, legacy passes `context:`
+          context = metadata[:context] || ((q = metadata[:query]) && q.context)
+          push_data = context
+          multiplex = context.query.multiplex
+        else
+          # Custom key, no backtrace data for this
+          nil
+        end
+
+        if push_data
+          multiplex.context[:last_graphql_backtrace_context] = push_data
+        end
+
+        if key == "execute_multiplex"
+          begin
+            yield
+          rescue StandardError => err
+            # This is an unhandled error from execution,
+            # Re-raise it with a GraphQL trace.
+            potential_context = metadata[:multiplex].context[:last_graphql_backtrace_context]
+
+            if potential_context.is_a?(GraphQL::Query::Context) || potential_context.is_a?(GraphQL::Query::Context::FieldResolutionContext)
+              raise TracedError.new(err, potential_context)
+            else
+              raise
+            end
+          ensure
+            metadata[:multiplex].context.delete(:last_graphql_backtrace_context)
+          end
+        else
+          yield
+        end
+      end
+    end
+  end
+end