graphql 1.8.1 → 1.8.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 6d3ae1b02473b2855990db63798b1c5d2fea46de
-  data.tar.gz: cfdc979146afea3eb44a969b66ac3a0763956db7
+  metadata.gz: 7cbf4bc1aa62d7f5ea7cec15027db39ca2162fe1
+  data.tar.gz: f622a8c446b557fb4fcdfb50e8868a808cb0b94b
 SHA512:
-  metadata.gz: 762efe82d940d001685c0cf242e1b6fc0c7ee9a5b77de66c4917268b6d2ae0340346daf707d74d41c9b1dd77b71c2d2d1f887e74e2eae2ab9c7869a787a5a74b
-  data.tar.gz: 4bcd06d7c866bb65154310cb8d11965902372860747aaaa99ebf44a73ebac3f6b1743e459e47730ba44e7fab57588031352bd1ed63925a42ec89550d32bf7906
+  metadata.gz: '0948dbb7c4dca8399a2c20a5e59bd823223c0662fb687e6062cdeb76709f0f5ad097bd6d0e77425d19125ddbd0ed4a1ba3ee88a3f5da61f2eae1a4dd34d8e7d7'
+  data.tar.gz: 409291f67651736ac996e6971b53fea7aa854983a69ad89887e6d71b68cef3550022317f83f268e23f83242c8e13ad71e65e5658da99aefa2e09c0c485ebda70

data/lib/generators/graphql/core.rb

@@ -16,7 +16,7 @@ module Graphql
 
       def insert_root_type(type, name)
         log :add_root_type, type
-        sentinel = /GraphQL\:\:Schema\.define do\s*\n/m
+        sentinel = /< GraphQL::Schema\s*\n/m
 
         in_root do
           inject_into_file schema_file_path, "  #{type}(Types::#{name})\n", after: sentinel, verbose: false, force: false

data/lib/generators/graphql/enum_generator.rb

@@ -3,11 +3,11 @@ require 'generators/graphql/type_generator'
 
 module Graphql
   module Generators
-    # Generate an interface type by name,
-    # with the specified fields.
+    # Generate an enum type by name, with the given values.
+    # To add a `value:` option, add another value after a `:`.
     #
     # ```
-    # rails g graphql:interface NamedEntityType name:String!
+    # rails g graphql:enum ProgrammingLanguage RUBY PYTHON PERL PERL6:"PERL"
     # ```
     class EnumGenerator < TypeGeneratorBase
       desc "Create a GraphQL::EnumType with the given name and values"

data/lib/generators/graphql/install_generator.rb

@@ -13,6 +13,11 @@ module Graphql
     #   - graphql/
     #     - resolvers/
     #     - types/
+    #       - base_enum.rb
+    #       - base_input_object.rb
+    #       - base_interface.rb
+    #       - base_object.rb
+    #       - base_union.rb
     #       - query_type.rb
     #     - loaders/
     #     - mutations/
@@ -40,6 +45,8 @@ module Graphql
     # Accept a `--batch` option which adds `GraphQL::Batch` setup.
     #
     # Use `--no-graphiql` to skip `graphiql-rails` installation.
+    #
+    # TODO: also add base classes
     class InstallGenerator < Rails::Generators::Base
       include Core
 
@@ -85,7 +92,11 @@ module Graphql
         create_dir("#{options[:directory]}/types")
         template("schema.erb", schema_file_path)
 
-        # Note: Yuo can't have a schema without the query type, otherwise introspection breaks
+        ["base_object", "base_enum", "base_input_object", "base_interface", "base_union"].each do |base_type|
+          template("#{base_type}.erb", "#{options[:directory]}/types/#{base_type}.rb")
+        end
+
+        # Note: You can't have a schema without the query type, otherwise introspection breaks
         template("query_type.erb", "#{options[:directory]}/types/query_type.rb")
         insert_root_type('query', 'QueryType')
 

data/lib/generators/graphql/mutation_generator.rb

@@ -6,12 +6,12 @@ module Graphql
   module Generators
     # TODO: What other options should be supported?
     #
-    # @example Generate a `Relay::Mutation` by name
+    # @example Generate a `GraphQL::Schema::RelayClassicMutation` by name
     #     rails g graphql:mutation CreatePostMutation
     class MutationGenerator < Rails::Generators::Base
       include Core
 
-      desc "Create a Relay mutation by name"
+      desc "Create a Relay Classic mutation by name"
       source_root File.expand_path('../templates', __FILE__)
 
       argument :name, type: :string
@@ -32,10 +32,10 @@ module Graphql
         else
           log :gsub, "#{options[:directory]}/types/mutation_type.rb"
         end
-        
+
         template "mutation.erb", "#{options[:directory]}/mutations/#{file_name}.rb"
 
-        sentinel = /name "Mutation"\s*\n/m
+        sentinel = /class .*MutationType/m
         in_root do
           gsub_file "#{options[:directory]}/types/mutation_type.rb", /  \# TODO\: Add Mutations as fields\s*\n/m, ""
           inject_into_file "#{options[:directory]}/types/mutation_type.rb", "  field :#{field_name}, Mutations::#{mutation_name}.field\n", after: sentinel, verbose: false, force: false

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

@@ -0,0 +1,2 @@
+class Types::BaseEnum < GraphQL::Schema::Enum
+end

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

@@ -0,0 +1,2 @@
+class Types::BaseInputObject < GraphQL::Schema::InputObject
+end

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

@@ -0,0 +1,3 @@
+module Types::BaseInterface
+  include GraphQL::Schema::Interface
+end

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

@@ -0,0 +1,2 @@
+class Types::BaseObject < GraphQL::Schema::Object
+end

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

@@ -0,0 +1,2 @@
+class Types::BaseUnion < GraphQL::Schema::Union
+end

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

@@ -1,4 +1,3 @@
-<%= type_ruby_name %> = GraphQL::EnumType.define do
-  name "<%= type_graphql_name %>"
+class <%= type_ruby_name %> < Types::BaseEnum
 <% prepared_values.each do |v| %>  value "<%= v[0] %>"<%= v.length > 1 ? ", value: #{v[1]}" : "" %>
 <% end %>end

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

@@ -1,4 +1,3 @@
-<%= type_ruby_name %> = GraphQL::InterfaceType.define do
-  name "<%= type_graphql_name %>"
-<% normalized_fields.each do |f| %>  field :<%= f[0] %>, <%= f[1] %>
+class <%= type_ruby_name %> < Types::BaseInterface
+<% normalized_fields.each do |f| %>  <%= f.to_ruby %>
 <% end %>end

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

@@ -1,12 +1,11 @@
-Mutations::<%= mutation_name %> = GraphQL::Relay::Mutation.define do
-  name "<%= mutation_name %>"
+class Mutations::<%= mutation_name %> < GraphQL::Schema::RelayClassicMutation
   # TODO: define return fields
   # return_field :post, Types::PostType
 
   # TODO: define arguments
   # input_field :name, !types.String
 
-  resolve ->(obj, args, ctx) {
-    # TODO: define resolve function
-  }
+  def resolve(**inputs)
+    # TODO: define resolve method
+  end
 end

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

@@ -1,11 +1,8 @@
-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!"
-    }
+class Types::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

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

@@ -1,5 +1,4 @@
-<%= type_ruby_name %> = GraphQL::ObjectType.define do
-  name "<%= type_graphql_name %>"
+class <%= type_ruby_name %> < Types::BaseObject
 <% if options.node %>  implements GraphQL::Relay::Node.interface
-<% end %><% normalized_fields.each do |f| %>  field :<%= f[0] %>, <%= f[1] %>
+<% end %><% normalized_fields.each do |f| %>  <%= f.to_ruby %>
 <% end %>end

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

@@ -1,15 +1,13 @@
-Types::QueryType = GraphQL::ObjectType.define do
-  name "Query"
+class Types::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) {
-      "Hello World!"
-    }
+  field :test_field, String, null: false,
+    description: "An example field added by the generator"
+  def test_field
+    "Hello World!"
   end
 <% if options[:relay] %>
-  field :node, GraphQL::Relay::Node.field
+  field :node, field: GraphQL::Relay::Node.field
 <% end %>end

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

@@ -1,31 +1,31 @@
-<%= schema_name %> = GraphQL::Schema.define do
+class <%= schema_name %> < GraphQL::Schema
 <% if options[:relay] %>
   # Relay Object Identification:
 
   # Return a string UUID for `object`
-  id_from_object ->(object, type_definition, query_ctx) {
+  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
-  object_from_id ->(id, query_ctx) {
+  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
     # ...
-  }
+  end
 
   # Object Resolution
-  resolve_type -> (type, obj, ctx) {
+  def self.resolve_type(type, obj, ctx)
     # TODO: Implement this function
     # to return the correct type for `obj`
     raise(NotImplementedError)
-  }
+  end
 <% end %><% if options[:batch] %>
   # GraphQL::Batch setup:
   use GraphQL::Batch

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

@@ -1,4 +1,3 @@
-<%= type_ruby_name %> = GraphQL::UnionType.define do
-  name "<%= type_graphql_name %>"
+class <%= type_ruby_name %> < Types::BaseUnion
 <% if possible_types.any? %>  possible_types [<%= normalized_possible_types.join(", ") %>]
 <% end %>end

data/lib/generators/graphql/type_generator.rb

@@ -21,33 +21,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 +60,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 +73,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/execution/execute.rb

@@ -211,10 +211,13 @@ module GraphQL
                   inner_ctx,
                 )
 
+                return PROPAGATE_NULL if inner_result == PROPAGATE_NULL
+
                 inner_ctx.value = inner_result
                 result << inner_ctx
                 i += 1
               end
+
               result
             when GraphQL::TypeKinds::NON_NULL
               inner_type = field_type.of_type

data/lib/graphql/schema.rb

@@ -652,6 +652,7 @@ module GraphQL
         # Configuration
         :max_complexity=, :max_depth=,
         :metadata,
+        :default_mask,
         :default_filter, :redefine,
         :id_from_object_proc, :object_from_id_proc,
         :id_from_object=, :object_from_id=, :type_error,

data/lib/graphql/schema/input_object.rb

@@ -27,7 +27,28 @@ module GraphQL
       attr_reader :arguments
 
       # Ruby-like hash behaviors, read-only
-      def_delegators :@ruby_style_hash, :to_h, :keys, :values, :each, :any?
+      def_delegators :@ruby_style_hash, :keys, :values, :each, :any?
+
+      def to_h
+        @ruby_style_hash.inject({}) do |h, (key, value)|
+          h.merge(key => unwrap_value(value))
+        end
+      end
+
+      def unwrap_value(value)
+        case value
+        when Array
+          value.map { |item| unwrap_value(item) }
+        when Hash
+          value.inject({}) do |h, (key, value)|
+            h.merge(key => unwrap_value(value))
+          end
+        when InputObject
+          value.to_h
+        else
+          value
+        end
+      end
 
       # Lookup a key on this object, it accepts new-style underscored symbols
       # Or old-style camelized identifiers.

data/lib/graphql/schema/relay_classic_mutation.rb

@@ -27,10 +27,14 @@ module GraphQL
 
       # Override {GraphQL::Schema::Mutation#resolve_mutation} to
       # delete `client_mutation_id` from the kwargs.
-      def resolve_mutation(kwargs)
+      def resolve_mutation(**kwargs)
         # This is handled by Relay::Mutation::Resolve, a bit hacky, but here we are.
         kwargs.delete(:client_mutation_id)
-        resolve(**kwargs)
+        if kwargs.any?
+          resolve(**kwargs)
+        else
+          resolve
+        end
       end
 
       resolve_method(:resolve_mutation)

data/lib/graphql/static_validation/all_rules.rb

@@ -24,6 +24,7 @@ module GraphQL
       GraphQL::StaticValidation::ArgumentsAreDefined,
       GraphQL::StaticValidation::ArgumentLiteralsAreCompatible,
       GraphQL::StaticValidation::RequiredArgumentsArePresent,
+      GraphQL::StaticValidation::ArgumentNamesAreUnique,
       GraphQL::StaticValidation::VariableNamesAreUnique,
       GraphQL::StaticValidation::VariablesAreInputTypes,
       GraphQL::StaticValidation::VariableDefaultValuesAreCorrectlyTyped,

data/lib/graphql/static_validation/rules/argument_names_are_unique.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+module GraphQL
+  module StaticValidation
+    class ArgumentNamesAreUnique
+      include GraphQL::StaticValidation::Message::MessageHelper
+
+      def validate(context)
+        context.visitor[GraphQL::Language::Nodes::Field] << ->(node, parent) {
+          validate_arguments(node, context)
+        }
+
+        context.visitor[GraphQL::Language::Nodes::Directive] << ->(node, parent) {
+          validate_arguments(node, context)
+        }
+      end
+
+      def validate_arguments(node, context)
+        argument_defns = node.arguments
+        if argument_defns.any?
+          args_by_name = Hash.new { |h, k| h[k] = [] }
+          argument_defns.each { |a| args_by_name[a.name] << a }
+          args_by_name.each do |name, defns|
+            if defns.size > 1
+              context.errors << message("There can be only one argument named \"#{name}\"", defns, context: context)
+            end
+          end
+        end
+      end
+    end
+  end
+end