graphql 1.8.0 → 1.12.12

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

@@ -1,12 +1,16 @@
-Mutations::<%= mutation_name %> = GraphQL::Relay::Mutation.define do
-  name "<%= mutation_name %>"
-  # TODO: define return fields
-  # return_field :post, Types::PostType
+<% module_namespacing_when_supported do -%>
+module Mutations
+  class <%= mutation_name %> < BaseMutation
+    # TODO: define return fields
+    # field :post, Types::PostType, null: false
 
-  # TODO: define arguments
-  # input_field :name, !types.String
+    # TODO: define arguments
+    # argument :name, String, required: true
 
-  resolve ->(obj, args, ctx) {
-    # TODO: define resolve function
-  }
+    # TODO: define resolve method
+    # def resolve(name:)
+    #   { post: ... }
+    # end
+  end
 end
+<% end -%>

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

@@ -1,11 +1,12 @@
-Types::MutationType = GraphQL::ObjectType.define do
-  name "Mutation"
-
-  # TODO: Remove me
-  field :testField, types.String do
-    description "An example field added by the generator"
-    resolve ->(obj, args, ctx) {
-      "Hello World!"
-    }
+<% module_namespacing_when_supported do -%>
+module Types
+  class MutationType < Types::BaseObject
+    # TODO: remove me
+    field :test_field, String, null: false,
+      description: "An example field added by the generator"
+    def test_field
+      "Hello World"
+    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,5 +1,8 @@
-<%= type_ruby_name %> = GraphQL::ObjectType.define do
-  name "<%= type_graphql_name %>"
-<% if options.node %>  implements GraphQL::Relay::Node.interface
-<% end %><% normalized_fields.each do |f| %>  field :<%= f[0] %>, <%= f[1] %>
-<% end %>end
+<% module_namespacing_when_supported do -%>
+module Types
+  class <%= type_ruby_name.split('::')[-1] %> < Types::BaseObject
+<% if options.node %>    implements GraphQL::Types::Relay::Node
+<% end %><% normalized_fields.each do |f| %>    <%= f.to_ruby %>
+<% end %>  end
+end
+<% end -%>

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

@@ -1,15 +1,15 @@
-Types::QueryType = GraphQL::ObjectType.define do
-  name "Query"
-  # Add root-level fields here.
-  # They will be entry points for queries on your schema.
+<% module_namespacing_when_supported do -%>
+module Types
+  class QueryType < Types::BaseObject
+    # Add root-level fields here.
+    # They will be entry points for queries on your schema.
 
-  # TODO: remove me
-  field :testField, types.String do
-    description "An example field added by the generator"
-    resolve ->(obj, args, ctx) {
+    # TODO: remove me
+    field :test_field, String, null: false,
+      description: "An example field added by the generator"
+    def test_field
       "Hello World!"
-    }
+    end
   end
-<% if options[:relay] %>
-  field :node, GraphQL::Relay::Node.field
-<% end %>end
+end
+<% end -%>

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

@@ -0,0 +1,15 @@
+<% module_namespacing_when_supported do -%>
+module Types
+  class <%= type_ruby_name.split('::')[-1] %> < Types::BaseScalar
+    def self.coerce_input(input_value, context)
+      # Override this to prepare a client-provided GraphQL value for your Ruby code
+      input_value
+    end
+
+    def self.coerce_result(ruby_value, context)
+      # Override this to serialize a Ruby value for the GraphQL response
+      ruby_value.to_s
+    end
+  end
+end
+<% end -%>

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

@@ -1,32 +1,15 @@
-<%= schema_name %> = GraphQL::Schema.define do
-<% if options[:relay] %>
-  # Relay Object Identification:
-
-  # Return a string UUID for `object`
-  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)
-  }
-
-  # Given a string UUID, find the object
-  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
-    # ...
-  }
-
-  # Object Resolution
-  resolve_type -> (type, obj, ctx) {
-    # TODO: Implement this function
-    # to return the correct type for `obj`
-    raise(NotImplementedError)
-  }
-<% end %><% if options[:batch] %>
+<% module_namespacing_when_supported do -%>
+class <%= schema_name %> < GraphQL::Schema
+  query(Types::QueryType)
+<% if options[:batch] %>
   # GraphQL::Batch setup:
   use GraphQL::Batch
-<% end %>end
+<% end %>
+  # Union and Interface Resolution
+  def self.resolve_type(abstract_type, obj, ctx)
+    # TODO: Implement this function
+    # to return the correct object type for `obj`
+    raise(GraphQL::RequiredImplementationMissingError)
+  end
+end
+<% end -%>

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

@@ -1,4 +1,7 @@
-<%= type_ruby_name %> = GraphQL::UnionType.define do
-  name "<%= type_graphql_name %>"
-<% if possible_types.any? %>  possible_types [<%= normalized_possible_types.join(", ") %>]
-<% end %>end
+<% 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(", ") %>
+<% 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'
@@ -21,33 +22,35 @@ module Graphql
       # TODO: nullability / list with `mode: :graphql` doesn't work
       # @param type_expresson [String]
       # @param mode [Symbol]
-      # @return [String]
-      def self.normalize_type_expression(type_expression, mode:)
+      # @param null [Boolean]
+      # @return [(String, Boolean)] The type expression, followed by `null:` value
+      def self.normalize_type_expression(type_expression, mode:, null: true)
         if type_expression.start_with?("!")
-          "!#{normalize_type_expression(type_expression[1..-1], mode: mode)}"
+          normalize_type_expression(type_expression[1..-1], mode: mode, null: false)
         elsif type_expression.end_with?("!")
-          "!#{normalize_type_expression(type_expression[0..-2], mode: mode)}"
+          normalize_type_expression(type_expression[0..-2], mode: mode, null: false)
         elsif type_expression.start_with?("[") && type_expression.end_with?("]")
-          "types[#{normalize_type_expression(type_expression[1..-2], mode: mode)}]"
-        elsif type_expression.start_with?("types[") && type_expression.end_with?("]")
-          "types[#{normalize_type_expression(type_expression[6..-2], mode: mode)}]"
+          name, is_null = normalize_type_expression(type_expression[1..-2], mode: mode, null: null)
+          ["[#{name}]", is_null]
         elsif type_expression.end_with?("Type")
-          normalize_type_expression(type_expression[0..-5], mode: mode)
+          normalize_type_expression(type_expression[0..-5], mode: mode, null: null)
         elsif type_expression.start_with?("Types::")
-          normalize_type_expression(type_expression[7..-1], mode: mode)
+          normalize_type_expression(type_expression[7..-1], mode: mode, null: null)
         elsif type_expression.start_with?("types.")
-          normalize_type_expression(type_expression[6..-1], mode: mode)
+          normalize_type_expression(type_expression[6..-1], mode: mode, null: null)
         else
           case mode
           when :ruby
             case type_expression
-            when "Int", "Float", "Boolean", "String", "ID"
-              "types.#{type_expression}"
+            when "Int"
+              ["Integer", null]
+            when "Integer", "Float", "Boolean", "String", "ID"
+              [type_expression, null]
             else
-              "Types::#{type_expression.camelize}Type"
+              ["Types::#{type_expression.camelize}Type", null]
             end
           when :graphql
-            type_expression.camelize
+            [type_expression.camelize, null]
           else
             raise "Unexpected normalize mode: #{mode}"
           end
@@ -58,12 +61,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)
+        @type_ruby_name ||= self.class.normalize_type_expression(type_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)
+        @type_graphql_name ||= self.class.normalize_type_expression(type_name, mode: :graphql)[0]
       end
 
       # @return [String] The user-provided type name, as a file name (without extension)
@@ -71,13 +74,26 @@ module Graphql
         @type_file_name ||= "#{type_graphql_name}Type".underscore
       end
 
-      # @return [Array<Array(String, String)>>] User-provided fields, in `(name, Ruby type name)` pairs
+      # @return [Array<NormalizedField>] User-provided fields, in `(name, Ruby type name)` pairs
       def normalized_fields
         @normalized_fields ||= fields.map { |f|
           name, raw_type = f.split(":", 2)
-          [name, self.class.normalize_type_expression(raw_type, mode: :ruby)]
+          type_expr, null = self.class.normalize_type_expression(raw_type, mode: :ruby)
+          NormalizedField.new(name, type_expr, null)
         }
       end
+
+      class NormalizedField
+        def initialize(name, type_expr, null)
+          @name = name
+          @type_expr = type_expr
+          @null = null
+        end
+
+        def to_ruby
+          "field :#{@name}, #{@type_expr}, null: #{@null}"
+        end
+      end
     end
   end
 end

data/lib/generators/graphql/union_generator.rb

@@ -26,7 +26,7 @@ module Graphql
       private
 
       def normalized_possible_types
-        possible_types.map { |t| self.class.normalize_type_expression(t, mode: :ruby) }
+        possible_types.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
@@ -27,7 +32,8 @@ module GraphQL
 
     # Visit `query`'s internal representation, calling `analyzers` along the way.
     #
-    # - First, query analyzers are initialized by calling `.initial_value(query)`, if they respond to that method.
+    # - First, query analyzers are filtered down by calling `.analyze?(query)`, if they respond to that method
+    # - Then, query analyzers are initialized by calling `.initial_value(query)`, if they respond to that method.
     # - Then, they receive `.call(memo, visit_type, irep_node)`, where visit type is `:enter` or `:leave`.
     # - Last, they receive `.final_value(memo)`, if they respond to that method.
     #
@@ -37,8 +43,18 @@ 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
-        reducer_states = analyzers.map { |r| ReducerState.new(r, query) } + multiplex_states
+        analyzers_to_run = analyzers.select do |analyzer|
+          if analyzer.respond_to?(:analyze?)
+            analyzer.analyze?(query)
+          else
+            true
+          end
+        end
+
+        reducer_states = analyzers_to_run.map { |r| ReducerState.new(r, query) } + multiplex_states
 
         irep = query.internal_representation
 

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

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+module GraphQL
+  module Analysis
+    module AST
+      # Query analyzer for query ASTs. Query analyzers respond to visitor style methods
+      # but are prefixed by `enter` and `leave`.
+      #
+      # When an analyzer is initialized with a Multiplex, you can always get the current query from
+      # `visitor.query` in the visit methods.
+      #
+      # @param [GraphQL::Query, GraphQL::Execution::Multiplex] The query or multiplex to analyze
+      class Analyzer
+        def initialize(subject)
+          @subject = subject
+
+          if subject.is_a?(GraphQL::Query)
+            @query = subject
+            @multiplex = nil
+          else
+            @multiplex = subject
+            @query = nil
+          end
+        end
+
+        # Analyzer hook to decide at analysis time whether a query should
+        # be analyzed or not.
+        # @return [Boolean] If the query should be analyzed or not
+        def analyze?
+          true
+        end
+
+        # The result for this analyzer. Returning {GraphQL::AnalysisError} results
+        # in a query error.
+        # @return [Any] The analyzer result
+        def result
+          raise GraphQL::RequiredImplementationMissingError
+        end
+
+        class << self
+          private
+
+          def build_visitor_hooks(member_name)
+            class_eval(<<-EOS, __FILE__, __LINE__ + 1)
+              def on_enter_#{member_name}(node, parent, visitor)
+              end
+
+              def on_leave_#{member_name}(node, parent, visitor)
+              end
+            EOS
+          end
+        end
+
+        build_visitor_hooks :argument
+        build_visitor_hooks :directive
+        build_visitor_hooks :document
+        build_visitor_hooks :enum
+        build_visitor_hooks :field
+        build_visitor_hooks :fragment_spread
+        build_visitor_hooks :inline_fragment
+        build_visitor_hooks :input_object
+        build_visitor_hooks :list_type
+        build_visitor_hooks :non_null_type
+        build_visitor_hooks :null_value
+        build_visitor_hooks :operation_definition
+        build_visitor_hooks :type_name
+        build_visitor_hooks :variable_definition
+        build_visitor_hooks :variable_identifier
+        build_visitor_hooks :abstract_node
+
+        protected
+
+        # @return [GraphQL::Query, GraphQL::Execution::Multiplex] Whatever this analyzer is analyzing
+        attr_reader :subject
+
+        # @return [GraphQL::Query, nil] `nil` if this analyzer is visiting a multiplex
+        #  (When this is `nil`, use `visitor.query` inside visit methods to get the current query)
+        attr_reader :query
+
+        # @return [GraphQL::Execution::Multiplex, nil] `nil` if this analyzer is visiting a query
+        attr_reader :multiplex
+      end
+    end
+  end
+end

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

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+module GraphQL
+  module Analysis
+    module AST
+      class FieldUsage < Analyzer
+        def initialize(query)
+          super
+          @used_fields = Set.new
+          @used_deprecated_fields = Set.new
+        end
+
+        def on_leave_field(node, parent, visitor)
+          field_defn = visitor.field_definition
+          field = "#{visitor.parent_type_definition.graphql_name}.#{field_defn.graphql_name}"
+          @used_fields << field
+          @used_deprecated_fields << field if field_defn.deprecation_reason
+        end
+
+        def result
+          {
+            used_fields: @used_fields.to_a,
+            used_deprecated_fields: @used_deprecated_fields.to_a
+          }
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+require_relative "./query_complexity"
+module GraphQL
+  module Analysis
+    module AST
+      # Used under the hood to implement complexity validation,
+      # see {Schema#max_complexity} and {Query#max_complexity}
+      class MaxQueryComplexity < QueryComplexity
+        def result
+          return if subject.max_complexity.nil?
+
+          total_complexity = max_possible_complexity
+
+          if total_complexity > subject.max_complexity
+            GraphQL::AnalysisError.new("Query has complexity of #{total_complexity}, which exceeds max complexity of #{subject.max_complexity}")
+          else
+            nil
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+module GraphQL
+  module Analysis
+    module AST
+      class MaxQueryDepth < QueryDepth
+        def result
+          configured_max_depth = if query
+            query.max_depth
+          else
+            multiplex.schema.max_depth
+          end
+
+          if configured_max_depth && @max_depth > configured_max_depth
+            GraphQL::AnalysisError.new("Query has depth of #{@max_depth}, which exceeds max depth of #{configured_max_depth}")
+          else
+            nil
+          end
+        end
+      end
+    end
+  end
+end