graphql 1.13.6 → 1.13.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d4cb09369d39b11ac4ebb242db3da4bc008a850cdd78c88816143cdfd84addd9
-  data.tar.gz: 4c5fc1be26724efda2dfc4e0f6ae0ad0ff9593b8708cf38ce3ec3a2ffae759d7
+  metadata.gz: 36daea28ec315c9949f4990d05993a15ea4568086f227d7dd7f151ce092747b6
+  data.tar.gz: 94d9e0598ff0756be7d7a4fde4c2c395ef47926003ad9d2718e9025ef0f7396a
 SHA512:
-  metadata.gz: ea28714d8d623e7591325672a08d031f03877f3744fdc18554ac0be2f2e3149dc2f99ee209f3b91d2d3f82564617d71eee5675a32ea1f60d0d75cc7cdffcf1b3
-  data.tar.gz: 492bd5f0312bb01a79175fdf87388e2ffd51a3bbe2d8a485a78e30f89634fd1a5ec28fbb1626ea775b38cd1984a3abfa2cc7ba58bd6189165fc91f923a668e30
+  metadata.gz: 00c1ba65cb41e6cbc9e4297a90b071f3915e9c8cc550a995f73d357d51ca299c5c478c24678efae9413d6f25fa69ec70b081ec31c120d03c71b93ba82ba291a3
+  data.tar.gz: 0b355f53d23bf5d2afeec35f0e33260a1565d79464a4d2dbc70f915c06964d116111211ba7eb070c3a7f3e86c5e9a31e318a30f5aa122f5ea1c608788f747e1e

data/lib/generators/graphql/core.rb

@@ -25,13 +25,6 @@ module Graphql
         end
       end
 
-      def create_mutation_root_type
-        create_dir("#{options[:directory]}/mutations")
-        template("base_mutation.erb", "#{options[:directory]}/mutations/base_mutation.rb", { skip: true })
-        template("mutation_type.erb", "#{options[:directory]}/types/mutation_type.rb", { skip: true })
-        insert_root_type('mutation', 'MutationType')
-      end
-
       def schema_file_path
         "#{options[:directory]}/#{schema_name.underscore}.rb"
       end

data/lib/generators/graphql/enum_generator.rb

@@ -13,20 +13,14 @@ module Graphql
       desc "Create a GraphQL::EnumType with the given name and values"
       source_root File.expand_path('../templates', __FILE__)
 
-      argument :values,
-        type: :array,
-        default: [],
-        banner: "value{:ruby_value} value{:ruby_value} ...",
-        desc: "Values for this enum (if present, ruby_value will be inserted verbatim)"
+      private
 
-      def create_type_file
-        template "enum.erb", "#{options[:directory]}/types/#{type_file_name}.rb"
+      def graphql_type
+        "enum"
       end
 
-      private
-
       def prepared_values
-        values.map { |v| v.split(":", 2) }
+        custom_fields.map { |v| v.split(":", 2) }
       end
     end
   end

data/lib/generators/graphql/field_extractor.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+require 'rails/generators/base'
+
+module Graphql
+  module Generators
+    module FieldExtractor
+      def fields
+        columns = []
+        columns += (klass&.columns&.map { |c| generate_column_string(c) }  || [])
+        columns + custom_fields
+      end
+
+      def generate_column_string(column)
+        name = column.name
+        required = column.null ? "" : "!"
+        type = column_type_string(column)
+        "#{name}:#{required}#{type}"
+      end
+
+      def column_type_string(column)
+        column.name == "id" ? "ID" : column.type.to_s.camelize
+      end
+
+      def klass
+        @klass ||= Module.const_get(name.camelize)
+      rescue NameError
+        @klass = nil
+      end
+    end
+  end
+end

data/lib/generators/graphql/input_generator.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+require 'generators/graphql/type_generator'
+require 'generators/graphql/field_extractor'
+
+module Graphql
+  module Generators
+    # Generate an input type by name,
+    # with the specified fields.
+    #
+    # ```
+    # rails g graphql:object PostType name:string!
+    # ```
+    class InputGenerator < TypeGeneratorBase
+      desc "Create a GraphQL::InputObjectType with the given name and fields"
+      source_root File.expand_path('../templates', __FILE__)
+      include FieldExtractor
+
+      def self.normalize_type_expression(type_expression, mode:, null: true)
+        case type_expression.camelize
+        when "Text", "Citext"
+          ["String", null]
+        when "Decimal"
+          ["Float", null]
+        when "DateTime", "Datetime"
+          ["GraphQL::Types::ISO8601DateTime", null]
+        when "Date"
+          ["GraphQL::Types::ISO8601Date", null]
+        when "Json", "Jsonb", "Hstore"
+          ["GraphQL::Types::JSON", null]
+        else
+          super
+        end
+      end
+
+      private
+
+      def graphql_type
+        "input"
+      end
+
+      def type_ruby_name
+        super.gsub(/Type\z/, "InputType")
+      end
+
+      def type_file_name
+        super.gsub(/_type\z/, "_input_type")
+      end
+    end
+  end
+end

data/lib/generators/graphql/install/mutation_root_generator.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+require "rails/generators/base"
+require_relative "../core"
+
+module Graphql
+  module Generators
+    module Install
+      class MutationRootGenerator < Rails::Generators::Base
+        include Core
+
+        desc "Create mutation base type, mutation root tipe, and adds the latter to the schema"
+        source_root File.expand_path('../templates', __FILE__)
+
+        class_option :schema,
+          type: :string,
+          default: nil,
+          desc: "Name for the schema constant (default: {app_name}Schema)"
+
+        class_option :skip_keeps,
+          type: :boolean,
+          default: false,
+          desc: "Skip .keep files for source control"
+
+        def generate
+          create_dir("#{options[:directory]}/mutations")
+          template("base_mutation.erb", "#{options[:directory]}/mutations/base_mutation.rb", { skip: true })
+          template("mutation_type.erb", "#{options[:directory]}/types/mutation_type.rb", { skip: true })
+          insert_root_type('mutation', 'MutationType') 
+        end
+      end
+    end
+  end
+end 

data/lib/generators/graphql/install_generator.rb

@@ -109,7 +109,7 @@ module Graphql
         template("query_type.erb", "#{options[:directory]}/types/query_type.rb")
         insert_root_type('query', 'QueryType')
 
-        create_mutation_root_type unless options.skip_mutation_root_type?
+        invoke "graphql:install:mutation_root" unless options.skip_mutation_root_type?
 
         template("graphql_controller.erb", "app/controllers/graphql_controller.rb")
         route('post "/graphql", to: "graphql#execute"')

data/lib/generators/graphql/interface_generator.rb

@@ -13,14 +13,14 @@ module Graphql
       desc "Create a GraphQL::InterfaceType with the given name and fields"
       source_root File.expand_path('../templates', __FILE__)
 
-      argument :fields,
-        type: :array,
-        default: [],
-        banner: "name:type name:type ...",
-        desc: "Fields for this interface (type may be expressed as Ruby or GraphQL)"
+      private
 
-      def create_type_file
-        template "interface.erb", "#{options[:directory]}/types/#{type_file_name}.rb"
+      def graphql_type
+        "interface"
+      end
+
+      def fields
+        custom_fields
       end
     end
   end

data/lib/generators/graphql/mutation_create_generator.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+require_relative 'orm_mutations_base'
+
+module Graphql
+  module Generators
+    # TODO: What other options should be supported?
+    #
+    # @example Generate a `GraphQL::Schema::RelayClassicMutation` by name
+    #     rails g graphql:mutation CreatePostMutation
+    class MutationCreateGenerator < OrmMutationsBase
+
+      desc "Scaffold a Relay Classic ORM create mutation for the given model class"
+      source_root File.expand_path('../templates', __FILE__)
+
+      private
+
+      def operation_type
+        "create"
+      end
+    end
+  end
+end

data/lib/generators/graphql/mutation_delete_generator.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+require_relative 'orm_mutations_base'
+
+module Graphql
+  module Generators
+    # TODO: What other options should be supported?
+    #
+    # @example Generate a `GraphQL::Schema::RelayClassicMutation` by name
+    #     rails g graphql:mutation CreatePostMutation
+    class MutationDeleteGenerator < OrmMutationsBase
+
+      desc "Scaffold a Relay Classic ORM delete mutation for the given model class"
+      source_root File.expand_path('../templates', __FILE__)
+
+      private
+
+      def operation_type
+        "delete"
+      end
+    end
+  end
+end

data/lib/generators/graphql/mutation_generator.rb

@@ -9,47 +9,22 @@ module Graphql
     #
     # @example Generate a `GraphQL::Schema::RelayClassicMutation` by name
     #     rails g graphql:mutation CreatePostMutation
-    class MutationGenerator < Rails::Generators::Base
+    class MutationGenerator < Rails::Generators::NamedBase
       include Core
 
       desc "Create a Relay Classic mutation by name"
       source_root File.expand_path('../templates', __FILE__)
 
-      argument :name, type: :string
-
-      def initialize(args, *options) # :nodoc:
-        # Unfreeze name in case it's given as a frozen string
-        args[0] = args[0].dup if args[0].is_a?(String) && args[0].frozen?
-        super
-
-        assign_names!(name)
-      end
-
-      attr_reader :file_name, :mutation_name, :field_name
-
       def create_mutation_file
-        unless @behavior == :revoke
-          create_mutation_root_type
-        else
-          log :gsub, "#{options[:directory]}/types/mutation_type.rb"
-        end
-
-        template "mutation.erb", "#{options[:directory]}/mutations/#{file_name}.rb"
+        template "mutation.erb", File.join(options[:directory], "/mutations/", class_path, "#{file_name}.rb")
 
         sentinel = /class .*MutationType\s*<\s*[^\s]+?\n/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}, mutation: Mutations::#{mutation_name}\n", after: sentinel, verbose: false, force: false
+          path = "#{options[:directory]}/types/mutation_type.rb"
+          invoke "graphql:install:mutation_root" unless File.exist?(path)
+          inject_into_file "#{options[:directory]}/types/mutation_type.rb", "    field :#{file_name}, mutation: Mutations::#{class_name}\n", after: sentinel, verbose: false, force: false
         end
       end
-
-      private
-
-      def assign_names!(name)
-        @field_name = name.camelize.underscore
-        @mutation_name = name.camelize(:upper)
-        @file_name = name.camelize.underscore
-      end
     end
   end
 end

data/lib/generators/graphql/mutation_update_generator.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+require_relative 'orm_mutations_base'
+
+module Graphql
+  module Generators
+    # TODO: What other options should be supported?
+    #
+    # @example Generate a `GraphQL::Schema::RelayClassicMutation` by name
+    #     rails g graphql:mutation CreatePostMutation
+    class MutationUpdateGenerator < OrmMutationsBase
+
+      desc "Scaffold a Relay Classic ORM update mutation for the given model class"
+      source_root File.expand_path('../templates', __FILE__)
+
+      private
+
+      def operation_type
+        "update"
+      end
+    end
+  end
+end

data/lib/generators/graphql/object_generator.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 require 'generators/graphql/type_generator'
+require 'generators/graphql/field_extractor'
 
 module Graphql
   module Generators
@@ -15,31 +16,16 @@ module Graphql
       desc "Create a GraphQL::ObjectType with the given name and fields." \
       "If the given type name matches an existing ActiveRecord model, the generated type will automatically include fields for the models database columns."
       source_root File.expand_path('../templates', __FILE__)
-
-      argument :custom_fields,
-               type: :array,
-               default: [],
-               banner: "name:type name:type ...",
-               desc: "Fields for this object (type may be expressed as Ruby or GraphQL)"
+      include FieldExtractor
 
       class_option :node,
                    type: :boolean,
                    default: false,
                    desc: "Include the Relay Node interface"
 
-      def create_type_file
-        template "object.erb", "#{options[:directory]}/types/#{type_file_name}.rb"
-      end
-
-      def fields
-        columns = []
-        columns += klass.columns.map { |c| generate_column_string(c) } if class_exists?
-        columns + custom_fields
-      end
-
       def self.normalize_type_expression(type_expression, mode:, null: true)
-        case type_expression
-        when "Text"
+        case type_expression.camelize
+        when "Text", "Citext"
           ["String", null]
         when "Decimal"
           ["Float", null]
@@ -47,6 +33,8 @@ module Graphql
           ["GraphQL::Types::ISO8601DateTime", null]
         when "Date"
           ["GraphQL::Types::ISO8601Date", null]
+        when "Json", "Jsonb", "Hstore"
+          ["GraphQL::Types::JSON", null]
         else
           super
         end
@@ -54,25 +42,8 @@ module Graphql
 
       private
 
-      def generate_column_string(column)
-        name = column.name
-        required = column.null ? "" : "!"
-        type = column_type_string(column)
-        "#{name}:#{required}#{type}"
-      end
-
-      def column_type_string(column)
-        column.name == "id" ? "ID" : column.type.to_s.camelize
-      end
-
-      def class_exists?
-        klass.is_a?(Class) && klass.ancestors.include?(ActiveRecord::Base)
-      rescue NameError
-        return false
-      end
-
-      def klass
-        @klass ||= Module.const_get(type_name.camelize)
+      def graphql_type
+        "object"
       end
     end
   end

data/lib/generators/graphql/orm_mutations_base.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+require 'rails/generators'
+require 'rails/generators/named_base'
+require_relative 'core'
+
+module Graphql
+  module Generators
+    # TODO: What other options should be supported?
+    #
+    # @example Generate a `GraphQL::Schema::RelayClassicMutation` by name
+    #     rails g graphql:mutation CreatePostMutation
+    class OrmMutationsBase < Rails::Generators::NamedBase
+      include Core
+      include Rails::Generators::ResourceHelpers
+
+      desc "Create a Relay Classic mutation by name"
+
+      class_option :orm, banner: "NAME", type: :string, required: true,
+                         desc: "ORM to generate the controller for"
+
+      class_option 'namespaced_types',
+        type: :boolean,
+        required: false,
+        default: false,
+        banner: "Namespaced",
+        desc: "If the generated types will be namespaced"
+
+      def create_mutation_file
+        template "mutation_#{operation_type}.erb", File.join(options[:directory], "/mutations/", class_path, "#{file_name}_#{operation_type}.rb")
+
+        sentinel = /class .*MutationType\s*<\s*[^\s]+?\n/m
+        in_root do
+          path = "#{options[:directory]}/types/mutation_type.rb"
+          invoke "graphql:install:mutation_root" unless File.exist?(path)
+          inject_into_file "#{options[:directory]}/types/mutation_type.rb", "    field :#{file_name}_#{operation_type}, mutation: Mutations::#{class_name}#{operation_type.classify}\n", after: sentinel, verbose: false, force: false
+        end
+      end
+    end
+  end
+end

data/lib/generators/graphql/scalar_generator.rb

@@ -12,8 +12,10 @@ module Graphql
       desc "Create a GraphQL::ScalarType with the given name"
       source_root File.expand_path('../templates', __FILE__)
 
-      def create_type_file
-        template "scalar.erb", "#{options[:directory]}/types/#{type_file_name}.rb"
+      private
+
+      def graphql_type
+        "scalar"
       end
     end
   end

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

@@ -1,6 +1,10 @@
+# frozen_string_literal: true
+
 <% module_namespacing_when_supported do -%>
 module Types
-  class <%= type_ruby_name.split('::')[-1] %> < Types::BaseEnum
+  class <%= ruby_class_name %> < Types::BaseEnum
+    description "<%= human_name %> enum"
+
 <% prepared_values.each do |v| %>    value "<%= v[0] %>"<%= v.length > 1 ? ", value: #{v[1]}" : "" %>
 <% end %>  end
 end

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/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/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/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,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/rubocop/graphql/default_required_true.rb

@@ -25,16 +25,16 @@ module GraphQL
 
         def_node_matcher :argument_config_with_required_true?, <<-Pattern
         (
-          send nil? :argument ... (hash <$(pair (sym :required) (true)) ...>)
+          send {nil? _} :argument ... (hash <$(pair (sym :required) (true)) ...>)
         )
         Pattern
 
         def on_send(node)
           argument_config_with_required_true?(node) do |required_config|
             add_offense(required_config) do |corrector|
-                cleaned_node_source = source_without_keyword_argument(node, required_config)
-                corrector.replace(node, cleaned_node_source)
-              end
+              cleaned_node_source = source_without_keyword_argument(node, required_config)
+              corrector.replace(node, cleaned_node_source)
+            end
           end
         end
       end

data/lib/graphql/schema/argument.rb

@@ -48,13 +48,21 @@ module GraphQL
       # @param directives [Hash{Class => Hash}]
       # @param deprecation_reason [String]
       # @param validates [Hash, nil] Options for building validators, if any should be applied
-      def initialize(arg_name = nil, type_expr = nil, desc = nil, required: true, type: nil, name: nil, loads: nil, description: nil, ast_node: nil, default_value: NO_DEFAULT, as: nil, from_resolver: false, camelize: true, prepare: nil, method_access: true, owner:, validates: nil, directives: nil, deprecation_reason: nil, &definition_block)
+      # @param replace_null_with_default [Boolean] if `true`, incoming values of `null` will be replaced with the configured `default_value`
+      def initialize(arg_name = nil, type_expr = nil, desc = nil, required: true, type: nil, name: nil, loads: nil, description: nil, ast_node: nil, default_value: NO_DEFAULT, as: nil, from_resolver: false, camelize: true, prepare: nil, method_access: true, owner:, validates: nil, directives: nil, deprecation_reason: nil, replace_null_with_default: false, &definition_block)
         arg_name ||= name
         @name = -(camelize ? Member::BuildType.camelize(arg_name.to_s) : arg_name.to_s)
         @type_expr = type_expr || type
         @description = desc || description
         @null = required != true
         @default_value = default_value
+        if replace_null_with_default
+          if !default_value?
+            raise ArgumentError, "`replace_null_with_default: true` requires a default value, please provide one with `default_value: ...`"
+          end
+          @replace_null_with_default = true
+        end
+
         @owner = owner
         @as = as
         @loads = loads
@@ -97,6 +105,10 @@ module GraphQL
         @default_value != NO_DEFAULT
       end
 
+      def replace_null_with_default?
+        @replace_null_with_default
+      end
+
       attr_writer :description
 
       # @return [String] Documentation for this argument
@@ -253,6 +265,11 @@ module GraphQL
           return
         end
 
+        if value.nil? && replace_null_with_default?
+          value = default_value
+          default_used = true
+        end
+
         loaded_value = nil
         coerced_value = context.schema.error_handler.with_error_handling(context) do
           type.coerce_input(value, context)

data/lib/graphql/schema/field.rb

@@ -38,7 +38,9 @@ module GraphQL
 
       # @return [Class] The GraphQL type this field belongs to. (For fields defined on mutations, it's the payload type)
       def owner_type
-        @owner_type ||= if owner < GraphQL::Schema::Mutation
+        @owner_type ||= if owner.nil?
+          raise GraphQL::InvariantError, "Field #{original_name.inspect} (graphql name: #{graphql_name.inspect}) has no owner, but all fields should have an owner. How did this happen?!"
+        elsif owner < GraphQL::Schema::Mutation
           owner.payload_type
         else
           owner
@@ -188,6 +190,7 @@ module GraphQL
       # @param deprecation_reason [String] If present, the field is marked "deprecated" with this message
       # @param method [Symbol] The method to call on the underlying object to resolve this field (defaults to `name`)
       # @param hash_key [String, Symbol] The hash key to lookup on the underlying object (if its a Hash) to resolve this field (defaults to `name` or `name.to_s`)
+      # @param dig [Array<String, Symbol>] The nested hash keys to lookup on the underlying hash to resolve this field using dig
       # @param resolver_method [Symbol] The method on the type to call to resolve this field (defaults to `name`)
       # @param connection [Boolean] `true` if this field should get automagic connection behavior; default is to infer by `*Connection` in the return type name
       # @param connection_extension [Class] The extension to add, to implement connections. If `nil`, no extension is added.
@@ -210,7 +213,7 @@ module GraphQL
       # @param method_conflict_warning [Boolean] If false, skip the warning if this field's method conflicts with a built-in method
       # @param validates [Array<Hash>] Configurations for validating this field
       # @param legacy_edge_class [Class, nil] (DEPRECATED) If present, pass this along to the legacy field definition
-      def initialize(type: nil, name: nil, owner: nil, null: true, field: nil, function: nil, description: nil, deprecation_reason: nil, method: nil, hash_key: nil, resolver_method: nil, resolve: nil, connection: nil, max_page_size: :not_given, scope: nil, introspection: false, camelize: true, trace: nil, complexity: 1, ast_node: nil, extras: EMPTY_ARRAY, extensions: EMPTY_ARRAY, connection_extension: self.class.connection_extension, resolver_class: nil, subscription_scope: nil, relay_node_field: false, relay_nodes_field: false, method_conflict_warning: true, broadcastable: nil, arguments: EMPTY_HASH, directives: EMPTY_HASH, validates: EMPTY_ARRAY, legacy_edge_class: nil, &definition_block)
+      def initialize(type: nil, name: nil, owner: nil, null: true, field: nil, function: nil, description: nil, deprecation_reason: nil, method: nil, hash_key: nil, dig: nil, resolver_method: nil, resolve: nil, connection: nil, max_page_size: :not_given, scope: nil, introspection: false, camelize: true, trace: nil, complexity: 1, ast_node: nil, extras: EMPTY_ARRAY, extensions: EMPTY_ARRAY, connection_extension: self.class.connection_extension, resolver_class: nil, subscription_scope: nil, relay_node_field: false, relay_nodes_field: false, method_conflict_warning: true, broadcastable: nil, arguments: EMPTY_HASH, directives: EMPTY_HASH, validates: EMPTY_ARRAY, legacy_edge_class: nil, &definition_block)
         if name.nil?
           raise ArgumentError, "missing first `name` argument or keyword `name:`"
         end
@@ -236,8 +239,8 @@ module GraphQL
         @resolve = resolve
         self.deprecation_reason = deprecation_reason
 
-        if method && hash_key
-          raise ArgumentError, "Provide `method:` _or_ `hash_key:`, not both. (called with: `method: #{method.inspect}, hash_key: #{hash_key.inspect}`)"
+        if method && hash_key && dig
+          raise ArgumentError, "Provide `method:`, `hash_key:` _or_ `dig:`, not multiple. (called with: `method: #{method.inspect}, hash_key: #{hash_key.inspect}, dig: #{dig.inspect}`)"
         end
 
         if resolver_method
@@ -245,13 +248,14 @@ module GraphQL
             raise ArgumentError, "Provide `method:` _or_ `resolver_method:`, not both. (called with: `method: #{method.inspect}, resolver_method: #{resolver_method.inspect}`)"
           end
 
-          if hash_key
-            raise ArgumentError, "Provide `hash_key:` _or_ `resolver_method:`, not both. (called with: `hash_key: #{hash_key.inspect}, resolver_method: #{resolver_method.inspect}`)"
+          if hash_key || dig
+            raise ArgumentError, "Provide `hash_key:`, `dig:`, _or_ `resolver_method:`, not multiple. (called with: `hash_key: #{hash_key.inspect}, dig: #{dig.inspect}, resolver_method: #{resolver_method.inspect}`)"
           end
         end
 
         # TODO: I think non-string/symbol hash keys are wrongly normalized (eg `1` will not work)
         method_name = method || hash_key || name_s
+        @dig_keys = dig
         resolver_method ||= name_s.to_sym
 
         @method_str = -method_name.to_s
@@ -822,7 +826,9 @@ module GraphQL
               end
             elsif obj.object.is_a?(Hash)
               inner_object = obj.object
-              if inner_object.key?(@method_sym)
+              if @dig_keys
+                inner_object.dig(*@dig_keys)
+              elsif inner_object.key?(@method_sym)
                 inner_object[@method_sym]
               else
                 inner_object[@method_str]

data/lib/graphql/schema.rb

@@ -1258,11 +1258,7 @@ module GraphQL
         when Module
           type_or_name
         else
-          raise ArgumentError, <<-ERR
-Invariant: unexpected field owner for #{field_name.inspect}: #{type_or_name.inspect} (#{type_or_name.class})
-
-This is probably a bug in GraphQL-Ruby, please report this error on GitHub: https://github.com/rmosolgo/graphql-ruby/issues/new?template=bug_report.md
-ERR
+          raise GraphQL::InvariantError, "Unexpected field owner for #{field_name.inspect}: #{type_or_name.inspect} (#{type_or_name.class})"
         end
 
         if parent_type.kind.fields? && (field = parent_type.get_field(field_name, context))

data/lib/graphql/types/iso_8601_date_time.rb

@@ -54,7 +54,14 @@ module GraphQL
         Time.iso8601(str_value)
       rescue ArgumentError, TypeError
         begin
-          Date.iso8601(str_value).to_time
+          dt = Date.iso8601(str_value).to_time
+          # For compatibility, continue accepting dates given without times
+          # But without this, it would zero out given any time part of `str_value` (hours and/or minutes)
+          if dt.iso8601.start_with?(str_value)
+            dt
+          else
+            nil
+          end
         rescue ArgumentError, TypeError
           # Invalid input
           nil

data/lib/graphql/types/relay/connection_behaviors.rb

@@ -83,7 +83,8 @@ module GraphQL
           end
 
           def visible?(ctx)
-            node_type.visible?(ctx)
+            # if this is an abstract base class, there may be no `node_type`
+            node_type ? node_type.visible?(ctx) : super
           end
 
           # Set the default `node_nullable` for this class and its child classes. (Defaults to `true`.)

data/lib/graphql/version.rb

@@ -1,4 +1,4 @@
 # frozen_string_literal: true
 module GraphQL
-  VERSION = "1.13.6"
+  VERSION = "1.13.7"
 end

data/lib/graphql.rb

@@ -17,6 +17,17 @@ module GraphQL
   class Error < StandardError
   end
 
+  # This error is raised when GraphQL-Ruby encounters a situation
+  # that it *thought* would never happen. Please report this bug!
+  class InvariantError < Error
+    def initialize(message)
+      message += "
+
+This is probably a bug in GraphQL-Ruby, please report this error on GitHub: https://github.com/rmosolgo/graphql-ruby/issues/new?template=bug_report.md"
+      super(message)
+    end
+  end
+
   class RequiredImplementationMissingError < Error
   end
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: graphql
 version: !ruby/object:Gem::Version
-  version: 1.13.6
+  version: 1.13.7
 platform: ruby
 authors:
 - Robert Mosolgo
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2022-01-20 00:00:00.000000000 Z
+date: 2022-01-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: benchmark-ips
@@ -245,11 +245,20 @@ files:
 - MIT-LICENSE
 - lib/generators/graphql/core.rb
 - lib/generators/graphql/enum_generator.rb
+- lib/generators/graphql/field_extractor.rb
+- lib/generators/graphql/input_generator.rb
+- lib/generators/graphql/install/mutation_root_generator.rb
+- lib/generators/graphql/install/templates/base_mutation.erb
+- lib/generators/graphql/install/templates/mutation_type.erb
 - lib/generators/graphql/install_generator.rb
 - lib/generators/graphql/interface_generator.rb
 - lib/generators/graphql/loader_generator.rb
+- lib/generators/graphql/mutation_create_generator.rb
+- lib/generators/graphql/mutation_delete_generator.rb
 - lib/generators/graphql/mutation_generator.rb
+- lib/generators/graphql/mutation_update_generator.rb
 - lib/generators/graphql/object_generator.rb
+- lib/generators/graphql/orm_mutations_base.rb
 - lib/generators/graphql/relay.rb
 - lib/generators/graphql/relay_generator.rb
 - lib/generators/graphql/scalar_generator.rb
@@ -260,16 +269,18 @@ files:
 - lib/generators/graphql/templates/base_field.erb
 - lib/generators/graphql/templates/base_input_object.erb
 - lib/generators/graphql/templates/base_interface.erb
-- lib/generators/graphql/templates/base_mutation.erb
 - lib/generators/graphql/templates/base_object.erb
 - lib/generators/graphql/templates/base_scalar.erb
 - lib/generators/graphql/templates/base_union.erb
 - lib/generators/graphql/templates/enum.erb
 - lib/generators/graphql/templates/graphql_controller.erb
+- lib/generators/graphql/templates/input.erb
 - lib/generators/graphql/templates/interface.erb
 - lib/generators/graphql/templates/loader.erb
 - lib/generators/graphql/templates/mutation.erb
-- lib/generators/graphql/templates/mutation_type.erb
+- lib/generators/graphql/templates/mutation_create.erb
+- lib/generators/graphql/templates/mutation_delete.erb
+- lib/generators/graphql/templates/mutation_update.erb
 - lib/generators/graphql/templates/node_type.erb
 - lib/generators/graphql/templates/object.erb
 - lib/generators/graphql/templates/query_type.erb