graphql 1.12.12 → 2.2.14

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 <% module_namespacing_when_supported do -%>
 class GraphqlController < ApplicationController
   # If accessing from outside this domain, nullify the session

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/loader.erb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 <% module_namespacing_when_supported do -%>
 module Loaders
   class <%= class_name %> < GraphQL::Batch::Loader

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

@@ -1,6 +1,8 @@
+# frozen_string_literal: true
+
 <% 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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 <% module_namespacing_when_supported do -%>
 module Types
   module NodeType

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
+  class <%= ruby_class_name %> < Types::BaseObject
 <% if options.node %>    implements GraphQL::Types::Relay::Node
-<% end %><% normalized_fields.each do |f| %>    <%= f.to_ruby %>
+<% end %><% normalized_fields.each do |f| %>    <%= f.to_object_field %>
 <% end %>  end
 end
 <% end -%>

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 <% module_namespacing_when_supported do -%>
 module Types
   class QueryType < Types::BaseObject

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,15 +1,32 @@
+# frozen_string_literal: true
+
 <% module_namespacing_when_supported do -%>
 class <%= schema_name %> < GraphQL::Schema
   query(Types::QueryType)
 <% 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
+
   # Union and Interface Resolution
   def self.resolve_type(abstract_type, obj, ctx)
-    # TODO: Implement this function
-    # to return the correct object type for `obj`
+    # TODO: Implement this method
+    # to return the correct GraphQL object type for `obj`
     raise(GraphQL::RequiredImplementationMissingError)
   end
+
+  # Stop validating when it encounters this many errors:
+  validate_max_errors(100)
 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

@@ -8,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
@@ -61,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)
@@ -83,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
@@ -90,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/analyzer.rb

@@ -29,6 +29,13 @@ module GraphQL
           true
         end
 
+        # Analyzer hook to decide at analysis time whether analysis
+        # requires a visitor pass; can be disabled for precomputed results.
+        # @return [Boolean] If analysis requires visitation or not
+        def visit?
+          true
+        end
+
         # The result for this analyzer. Returning {GraphQL::AnalysisError} results
         # in a query error.
         # @return [Any] The analyzer result

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

@@ -7,6 +7,8 @@ module GraphQL
           super
           @used_fields = Set.new
           @used_deprecated_fields = Set.new
+          @used_deprecated_arguments = Set.new
+          @used_deprecated_enum_values = Set.new
         end
 
         def on_leave_field(node, parent, visitor)
@@ -14,14 +16,66 @@ 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, field_defn)
+          # 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,
+            used_deprecated_enum_values: @used_deprecated_enum_values.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
+
+            next if argument.value.nil?
+
+            argument_type = argument.definition.type
+            if argument_type.non_null?
+              argument_type = argument_type.of_type
+            end
+
+            if argument_type.kind.input_object?
+              extract_deprecated_arguments(argument.value.arguments.argument_values) # rubocop:disable Development/ContextIsPassedCop -- runtime args instance
+            elsif argument_type.kind.enum?
+              extract_deprecated_enum_value(argument_type, argument.value)
+            elsif argument_type.list?
+              inner_type = argument_type.unwrap
+              case inner_type.kind
+              when TypeKinds::INPUT_OBJECT
+                argument.value.each do |value|
+                  extract_deprecated_arguments(value.arguments.argument_values) # rubocop:disable Development/ContextIsPassedCop -- runtime args instance
+                end
+              when TypeKinds::ENUM
+                argument.value.each do |value|
+                  extract_deprecated_enum_value(inner_type, value)
+                end
+              else
+                # Not a kind of input that we track
+              end
+            end
+          end
+        end
+
+        def extract_deprecated_enum_value(enum_type, value)
+          enum_value = @query.warden.enum_values(enum_type).find { |ev| ev.value == value }
+          if enum_value&.deprecation_reason
+            @used_deprecated_enum_values << enum_value.path
+          end
+        end
       end
     end
   end

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

@@ -1,5 +1,4 @@
 # frozen_string_literal: true
-require_relative "./query_complexity"
 module GraphQL
   module Analysis
     module AST