graphql-rails-api 0.9.3 → 0.9.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: dfe867c4f64d230748b3d8a9d1aece95a16c6692d96491fd67298ad522ddd5ce
-  data.tar.gz: 0a407e15eff08e02e8a202da0d47d3fe6116af42eb591421e3b5a914964f7a48
+  metadata.gz: 1bb023539d96953816444d9bfb1c00a93143e7bf78bb6bd01fbdc90a2c8f9c52
+  data.tar.gz: fa272ef8fc02dd009221281694d1f567c4a3d3ef62a45d0129e5477cb145ba37
 SHA512:
-  metadata.gz: e508676774b519da77b95483e1a0d28a91e1843925dc1669f674cb958d911ada161968923a385d86af51b86d47af56baecff3fe5a959cb1b727aed556834df6c
-  data.tar.gz: 3e1aefb503057898ba28eb3008fd2e8b4c63f792fd530ac0a3bcfdf8754ed168a5b5f7f6c1dbaf76f96961494bd03da7f905fc57ba19ccaabd26af1eb8dddffc
+  metadata.gz: d72815cf15edf05a92ac0c49752acebb7f390999232caec1d7960b8d486f96b27e2a1cce616470e7627814a6f5161101a2c7f0c5af6d741d52186fe7371fe587
+  data.tar.gz: dc1a6d286bf8cfe6d6a2a2bb2398906f0ee860079d7acf46f88134dba05aa2775f227506fa978d05b696ac320357d9e8e653c313761a03cb55a9422e3b43b07d

data/lib/generators/graphql_add_fields/graphql_add_fields_generator.rb

@@ -8,13 +8,13 @@ class GraphqlAddFieldsGenerator < Rails::Generators::NamedBase
   end
 
   TYPES_MAPPING = {
-    'id' => 'types.String',
-    'uuid' => 'types.String',
-    'boolean' => 'types.Boolean',
-    'float' => 'types.Float',
-    'decimal' => 'types.Float',
-    'integer' => 'types.Int',
-    'bigint' => 'types.Int'
+    'id' => 'String',
+    'uuid' => 'String',
+    'boolean' => 'Boolean',
+    'float' => 'Float',
+    'decimal' => 'Float',
+    'integer' => 'Integer',
+    'bigint' => 'Integer'
   }.freeze
 
   def create_graphql_files
@@ -35,30 +35,30 @@ class GraphqlAddFieldsGenerator < Rails::Generators::NamedBase
     add_has_many_to_models(@resource) if options.propagation?
     add_has_many_fields_to_types(@resource) if options.propagation?
 
-    system('bundle exec rails db:migrate') if options.migrate?
+    # system('bundle exec rails db:migrate') if options.migrate?
   end
 
   private
 
   def types_mapping(type)
-    TYPES_MAPPING[type] || 'types.String'
+    TYPES_MAPPING[type] || 'String'
   end
 
   def complete_graphql_input_type
     return if map_types(input_type: true).blank?
 
-    write_at("#{@mutations_directory}/input_type.rb", 4, "  #{map_types(input_type: true)}\n")
+    write_at("#{@mutations_directory}/input_type.rb", 7, "      #{map_types(input_type: true)}\n")
   end
 
   def complete_graphql_type(resource)
     return if map_types(input_type: false).blank?
 
-    write_at("#{graphql_resource_directory(resource)}/type.rb", 4, "  #{map_types(input_type: false)}\n")
+    write_at("#{graphql_resource_directory(resource)}/type.rb", 6, "    #{map_types(input_type: false)}\n")
   end
 
   def parse_args
     @id_db_type = 'uuid'
-    @id_type = 'types.String'
+    @id_type = 'String'
 
     @resource = file_name.singularize
     @has_many = []
@@ -114,13 +114,8 @@ class GraphqlAddFieldsGenerator < Rails::Generators::NamedBase
     end
 
     write_at(
-      file_name, 4,
-      <<-STRING
-  field :#{resource.singularize}_ids, types[#{@id_type}] do
-    resolve CollectionIdsResolver
-  end
-  field :#{resource.pluralize}, types[#{resource.pluralize.camelize}::Type]
-        STRING
+      file_name, 6,
+      "    field :#{resource.pluralize}, [#{resource.pluralize.camelize}::Type], null: true\n"
     )
 
     input_type_file_name = "app/graphql/#{field.pluralize}/mutations/input_type.rb"
@@ -130,10 +125,8 @@ class GraphqlAddFieldsGenerator < Rails::Generators::NamedBase
     end
 
     write_at(
-      input_type_file_name, 4,
-      <<-STRING
-  argument :#{resource.singularize}_ids, types[#{@id_type}]
-      STRING
+      input_type_file_name, 7,
+      "      argument :#{resource.singularize}_ids, [#{@id_type}], required: false\n"
     )
   end
 
@@ -145,11 +138,8 @@ class GraphqlAddFieldsGenerator < Rails::Generators::NamedBase
     end
 
     write_at(
-      file_name, 4,
-      <<-STRING
-  field :#{field.singularize}_id, #{@id_type}
-  field :#{field.singularize}, #{field.pluralize.camelize}::Type
-      STRING
+      file_name, 6,
+      "    field :#{field.singularize}_id, #{@id_type}, null: false\n    field :#{field.singularize}, #{field.pluralize.camelize}::Type, null: false\n"
     )
     input_type_file_name = "app/graphql/#{resource.pluralize}/mutations/input_type.rb"
     if File.read(input_type_file_name).include?("argument :#{field.singularize}_id") ||
@@ -158,10 +148,8 @@ class GraphqlAddFieldsGenerator < Rails::Generators::NamedBase
     end
 
     write_at(
-      input_type_file_name, 4,
-      <<-STRING
-  argument :#{field.singularize}_id, #{@id_type}
-      STRING
+      input_type_file_name, 7,
+      "      argument :#{field.singularize}_id, #{@id_type}, required: false\n"
     )
   end
 
@@ -225,14 +213,14 @@ t.#{@id_db_type} :#{resource.underscore.singularize}_id
     result = args&.map do |k, v|
       field_name = k
       field_type = types_mapping(v)
-      res = "#{input_type ? 'argument' : 'field'} :#{field_name}, #{field_type}"
+      res = "#{input_type ? 'argument' : 'field'} :#{field_name}, #{field_type}, #{input_type ? "required: false" : "null: true"}"
       if !input_type && field_name.ends_with?('_id') && @belongs_to_fields.key?(field_name)
-        res += "\n  field :#{field_name.gsub('_id', '')}, " \
+        res += "\n    field :#{field_name.gsub('_id', '')}, " \
           "#{field_name.gsub('_id', '').pluralize.camelize}::Type"
       end
       res
-    end&.join("\n  ")
-    input_type ? result.gsub("field :id, #{@id_type}\n", '') : result
+    end&.join("\n    " + ("  " if input_type).to_s)
+    input_type ? result.gsub("field :id, #{@id_type}, null: false\n", '') : result
   end
 
   # Helpers methods
@@ -248,13 +236,13 @@ t.#{@id_db_type} :#{resource.underscore.singularize}_id
     file = open(file_name)
     line_count = file.readlines.size
     line_nb = 0
-    file.each do |l|
+    IO.readlines(file).each do |l|
       line_nb += 1
       break if l.include?('ApplicationRecord')
     end
     raise 'Your model must inherit from ApplicationRecord to make it work' if line_nb >= line_count
 
-    write_at(file_name, line_nb + 2, "  #{line}\n")
+    write_at(file_name, line_nb + 1, "  #{line}\n")
   end
 
   def generate_has_many_migration(resource, has_many:)

data/lib/generators/graphql_mutations/graphql_mutations_generator.rb

@@ -1,5 +1,4 @@
 class GraphqlMutationsGenerator < Rails::Generators::NamedBase
-
   def generate
     resource = file_name.underscore.singularize
     dir = "app/graphql/#{resource.pluralize}/mutations"
@@ -7,55 +6,30 @@ class GraphqlMutationsGenerator < Rails::Generators::NamedBase
     generate_create_mutation(dir, resource)
     generate_update_mutation(dir, resource)
     generate_destroy_mutation(dir, resource)
-    generate_bulk_create_mutation(dir, resource)
-    generate_bulk_update_mutation(dir, resource)
   end
 
   private
 
-  def generate_bulk_create_mutation(dir, resource)
-    File.write(
-      "#{dir}/bulk_create.rb",
-      <<~STRING
-        #{resource_class(resource)}::Mutations::BulkCreate = GraphQL::Field.define do
-          description 'creates some #{resource_class(resource).pluralize}'
-          type types[#{resource_class(resource)}::Type]
-
-          argument :#{resource}, !types[#{resource_class(resource)}::Mutations::InputType]
-
-          resolve ApplicationService.call(:#{resource}, :bulk_create)
-        end
-      STRING
-    )
-  end
-
-  def generate_bulk_update_mutation(dir, resource)
-    File.write(
-      "#{dir}/bulk_update.rb",
-      <<~STRING
-        #{resource_class(resource)}::Mutations::BulkUpdate = GraphQL::Field.define do
-          description 'Updates some #{resource_class(resource).pluralize}'
-          type types[#{resource_class(resource)}::Type]
-
-          argument :#{resource}, !types[#{resource_class(resource)}::Mutations::InputType]
-
-          resolve ApplicationService.call(:#{resource}, :bulk_update)
-        end
-      STRING
-    )
-  end
-
   def generate_create_mutation(dir, resource)
     File.write(
       "#{dir}/create.rb",
       <<~STRING
-        #{resource_class(resource)}::Mutations::Create = GraphQL::Field.define do
-          description 'Creates a #{resource_class(resource).singularize}'
-          type #{resource_class(resource)}::Type
-
-          argument :#{resource}, !#{resource_class(resource)}::Mutations::InputType
-
-          resolve ApplicationService.call(:#{resource}, :create)
+        module #{resource_class(resource)}
+          module Mutations
+            class Create < GraphQL::Schema::Mutation
+              graphql_name "Create#{resource_class(resource)}"
+              description "Create a #{resource_class(resource).singularize}"
+
+              field :errors, [String], null: true
+              field :#{resource}, #{resource_class(resource)}::Type, null: true
+
+              argument :attributes, #{resource_class(resource)}::Mutations::InputType, required: false
+
+              def resolve(attributes:)
+                ApplicationService.call(:#{resource}, :create, context, attributes)
+              end
+            end
+          end
         end
       STRING
     )
@@ -65,14 +39,23 @@ class GraphqlMutationsGenerator < Rails::Generators::NamedBase
     File.write(
       "#{dir}/update.rb",
       <<~STRING
-        #{resource_class(resource)}::Mutations::Update = GraphQL::Field.define do
-          description 'Updates a #{resource_class(resource).singularize}'
-          type #{resource_class(resource)}::Type
-
-          argument :id, types.String
-          argument :#{resource}, !#{resource_class(resource)}::Mutations::InputType
-
-          resolve ApplicationService.call(:#{resource}, :update)
+        module #{resource_class(resource)}
+          module Mutations
+            class Update < GraphQL::Schema::Mutation
+              graphql_name "Update#{resource_class(resource)}"
+              description "Update a #{resource_class(resource).singularize}"
+
+              field :errors, [String], null: true
+              field :#{resource}, #{resource_class(resource)}::Type, null: true
+
+              argument :id, String, required: true
+              argument :attributes, #{resource_class(resource)}::Mutations::InputType, required: false
+
+              def resolve(id:, attributes:)
+                ApplicationService.call(:#{resource}, :update, context, id, attributes)
+              end
+            end
+          end
         end
       STRING
     )
@@ -82,13 +65,22 @@ class GraphqlMutationsGenerator < Rails::Generators::NamedBase
     File.write(
       "#{dir}/destroy.rb",
       <<~STRING
-        #{resource_class(resource)}::Mutations::Destroy = GraphQL::Field.define do
-          description 'Destroys a #{resource_class(resource).singularize}'
-          type #{resource_class(resource)}::Type
-
-          argument :id, !types.String
-
-          resolve ApplicationService.call(:#{resource}, :destroy)
+        module #{resource_class(resource)}
+          module Mutations
+            class Destroy < GraphQL::Schema::Mutation
+              graphql_name "Destroy#{resource_class(resource)}"
+              description "Destroy a #{resource_class(resource).singularize}"
+
+              field :errors, [String], null: true
+              field :#{resource}, #{resource_class(resource)}::Type, null: true
+
+              argument :id, String, required: true
+
+              def resolve(id:)
+                ApplicationService.call(:#{resource}, :destroy, context, id)
+              end
+            end
+          end
         end
       STRING
     )
@@ -97,5 +89,4 @@ class GraphqlMutationsGenerator < Rails::Generators::NamedBase
   def resource_class(resource)
     @resource_class ||= resource.pluralize.camelize
   end
-
 end

data/lib/generators/graphql_rails_api/install_generator.rb

@@ -3,7 +3,6 @@ require 'graphql/rails/api/config'
 module GraphqlRailsApi
   class InstallGenerator < Rails::Generators::Base
 
-    class_option('apollo_compatibility', type: :boolean, default: true)
     class_option('generate_graphql_route', type: :boolean, default: true)
 
     def generate_files
@@ -165,18 +164,18 @@ end
       File.write(
         'app/graphql/mutation_type.rb',
         <<~'STRING'
-          MutationType = GraphQL::ObjectType.define do
-            name 'Mutation'
+          class MutationType < GraphQL::Schema::Object
+            graphql_name "Mutation"
+            description "The mutation root of this schema"
 
             Graphql::Rails::Api::Config.mutation_resources.each do |methd, resources|
               resources.each do |resource|
                 field(
                   "#{methd}_#{resource.singularize}".to_sym,
-                  "#{resource.camelize}::Mutations::#{methd.camelize}".constantize
+                  mutation: "#{resource.camelize}::Mutations::#{methd.camelize}".constantize
                 )
               end
             end
-
           end
         STRING
       )
@@ -186,59 +185,71 @@ end
       File.write(
         'app/graphql/query_type.rb',
         <<~'STRING'
-          QueryType = GraphQL::ObjectType.define do
-            name 'Query'
+          class QueryType < GraphQL::Schema::Object
+            description "The query root of this schema"
 
             Graphql::Rails::Api::Config.query_resources.each do |resource|
-              field resource.singularize do
-                description "Returns a #{resource.classify}"
-                type !"#{resource.camelize}::Type".constantize
-                argument :id, !types.String
-                resolve ApplicationService.call(resource, :show)
+              klass = Class.new(GraphQL::Schema::Object) do
+                graphql_name "Paginated#{resource.classify}"
+
+                field :total_count, Integer, null: false
+                field :page, Integer, null: false
+                field :per_page, Integer, null: false
+                field :data, ["#{resource.pluralize.camelize}::Type".constantize], null: false
               end
 
-              field resource.pluralize do
-                description "Returns a #{resource.classify}"
-                type !types[!"#{resource.camelize}::Type".constantize]
-                argument :page, types.Int
-                argument :per_page, types.Int
-                argument :filter, types.String
-                argument :order_by, types.String
-                resolve ApplicationService.call(resource, :index)
+              resource.pluralize.camelize.constantize.const_set(
+                :PaginatedType,
+                klass
+              )
+
+              field "paginated_#{resource.pluralize}", "#{resource.camelize}::PaginatedType".constantize, null: false do
+                description "Return paginated #{resource.classify}"
+                argument :page, Integer, required: true
+                argument :per_page, Integer, required: true
+                argument :filter, String, required: false
+                argument :order_by, type: String, required: false
               end
 
-            end
+              define_method("paginated_#{resource.pluralize}") do |page:, per_page:, filter: nil, order_by: nil|
+                arguments = {
+                  page: page,
+                  per_page: per_page,
+                  filter: filter,
+                  order_by: order_by
+                }
+                ApplicationService.call(resource, :paginated_index, context, arguments)
+              end
 
-            field :me, Users::Type do
-              description 'Returns the current user'
-              resolve ->(_, _, ctx) { ctx[:current_user] }
-            end
+              field resource.pluralize.to_sym, ["#{resource.camelize}::Type".constantize], null: false do
+                description "All #{resource.pluralize}"
+                argument :page, Integer, required: false
+                argument :per_page, Integer, required: false
+                argument :filter, String, required: false
+                argument :order_by, String, required: false
+              end
 
+              define_method(resource.pluralize) do |page: nil, per_page: nil, filter: nil, order_by: nil|
+                arguments = {page: page, per_page: per_page, filter: filter, order_by: order_by}
+                ApplicationService.call(resource, :index, context, arguments)
+              end
+
+              field resource.singularize.to_sym, "#{resource.camelize}::Type".constantize, null: false do
+                description "A #{resource.singularize}"
+                argument :id, String, required: true
+              end
+
+              define_method(resource.singularize) do |id:|
+                arguments = {id: id}
+                ApplicationService.call(resource, :show, context, arguments)
+              end
+            end
           end
+
         STRING
       )
     end
 
-    def apollo_compat
-      <<~'STRING'
-        # /!\ do not remove /!\
-        # Apollo Data compat.
-        ClientDirective = GraphQL::Directive.define do
-          name 'client'
-          locations([GraphQL::Directive::FIELD])
-          default_directive true
-        end
-        ConnectionDirective = GraphQL::Directive.define do
-          name 'connection'
-          locations([GraphQL::Directive::FIELD])
-          argument :key, GraphQL::STRING_TYPE
-          argument :filter, GraphQL::STRING_TYPE.to_list_type
-          default_directive true
-        end
-        # end of Apollo Data compat.
-      STRING
-    end
-
     def write_schema
       logger = <<~'STRING'
         type_error_logger = Logger.new("#{Rails.root}/log/graphql_type_errors.log")
@@ -252,18 +263,20 @@ end
       File.write(
         "app/graphql/#{@app_name}_schema.rb",
         <<~STRING
-          #{logger}
-          #{apollo_compat if options.apollo_compatibility?}
-          # Schema definition
-          #{@app_name.camelize}Schema = GraphQL::Schema.define do
-            mutation(MutationType)
-            query(QueryType)
-            #{'directives [ConnectionDirective, ClientDirective]' if options.apollo_compatibility?}
-            type_error lambda { |err, query_ctx|
-              #{error_handler}
-            }
+          class #{@app_name.camelize}Schema < GraphQL::Schema
+            query QueryType
+            mutation MutationType
+            max_depth 15
+
+            def self.type_error(err, query_ctx)
+              type_error_logger = Logger.new("#{Rails.root}/log/graphql_type_errors.log")
+
+              type_error_logger.error(
+                "#{err} for #{query_ctx.query.query_string} with #{query_ctx.query.provided_variables}"
+              )
+            end
           end
-        STRING
+        <<~STRING
       )
     end
 
@@ -317,41 +330,17 @@ end
               return not_allowed if not_allowed_to_create_resource(object)
 
               if object.save
-                object
+                { singular_resource => Graphql::HydrateQuery.new(model.all, @context, user: user, id: object.id).run }
               else
                 graphql_error(object.errors.full_messages.join(', '))
               end
             end
 
-            def bulk_create
-              result = model.import(params.map { |p| p.select { |param| model.new.respond_to?(param) } })
-              result.each { |e| e.run_callbacks(:save) }
-              hyd = Graphql::HydrateQuery.new(model.where(id: result.ids), @context).run.compact + result.failed_instances.map do |i|
-                graphql_error(i.errors.full_messages)
-              end
-              return hyd.first if hyd.all? { |e| e.is_a?(GraphQL::ExecutionError) }
-
-              hyd
-            end
-
-            def bulk_update
-              visible_ids = model.where(id: params.map { |p| p[:id] }).pluck(:id)
-              return not_allowed if (model.visible_for(user: user).pluck(:id) & visible_ids).size < visible_ids.size
-
-              hash = params.each_with_object({}) { |p, h| h[p.delete(:id)] = p }
-              failed_instances = []
-              result = model.update(hash.keys, hash.values).map { |e| e.errors.blank? ? e : (failed_instances << e && nil) }
-              hyd = Graphql::HydrateQuery.new(model.where(id: result.compact.map(&:id)), @context).run.compact + failed_instances.map do |i|
-                graphql_error(i.errors.full_messages)
-              end
-              hyd.all? { |e| e.is_a?(GraphQL::ExecutionError) } ? hyd.first : hyd
-            end
-
             def update
               return not_allowed if write_not_allowed
 
               if object.update_attributes(params)
-                object
+                { singular_resource => Graphql::HydrateQuery.new(model.all, @context, user: user, id: object.id).run }
               else
                 graphql_error(object.errors.full_messages.join(', '))
               end
@@ -362,7 +351,7 @@ end
               return not_allowed if write_not_allowed
 
               if object.destroy
-                object
+                { singular_resource => object.attributes }
               else
                 graphql_error(object.errors.full_messages.join(', '))
               end

data/lib/generators/graphql_resource/graphql_resource_generator.rb

@@ -1,20 +1,19 @@
 class GraphqlResourceGenerator < Rails::Generators::NamedBase
-
   %i[
     migration model mutations service graphql_input_type
-    graphql_type propagation connection migrate
+    graphql_type propagation migrate
   ].each do |opt|
     class_option(opt, type: :boolean, default: true)
   end
 
   TYPES_MAPPING = {
-    'id' => 'types.String',
-    'uuid' => 'types.String',
-    'boolean' => 'types.Boolean',
-    'float' => 'types.Float',
-    'decimal' => 'types.Float',
-    'integer' => 'types.Int',
-    'bigint' => 'types.Int'
+    "id" => "String",
+    "uuid" => "String",
+    "boolean" => "Boolean",
+    "float" => "Float",
+    "decimal" => "Float",
+    "integer" => "Integer",
+    "bigint" => "Integer"
   }.freeze
 
   def create_graphql_files
@@ -42,18 +41,18 @@ class GraphqlResourceGenerator < Rails::Generators::NamedBase
     add_has_many_to_models(@resource) if options.propagation?
     add_has_many_fields_to_types(@resource) if options.propagation?
 
-    system('bundle exec rails db:migrate') if options.migrate?
+    # system("bundle exec rails db:migrate") if options.migrate?
   end
 
   private
 
   def types_mapping(type)
-    TYPES_MAPPING[type] || 'types.String'
+    TYPES_MAPPING[type] || "String"
   end
 
   def parse_args
-    @id_db_type = 'uuid'
-    @id_type = 'types.String'
+    @id_db_type = "uuid"
+    @id_type = "String"
 
     @resource = file_name.singularize
     @has_many = []
@@ -62,21 +61,21 @@ class GraphqlResourceGenerator < Rails::Generators::NamedBase
     @belongs_to_fields = {}
 
     @args = args.each_with_object({}) do |f, hash|
-      next if f.split(':').count != 2
-
-      case f.split(':').first
-      when 'belongs_to' then
-        hash["#{f.split(':').last.singularize}_id"] = @id_db_type
-        @belongs_to_fields["#{f.split(':').last.singularize}_id"] = @id_db_type
-      when 'has_many' then @has_many << f.split(':').last.pluralize
-      when 'many_to_many' then @many_to_many << f.split(':').last.pluralize
+      next if f.split(":").count != 2
+
+      case f.split(":").first
+      when "belongs_to"
+        hash["#{f.split(":").last.singularize}_id"] = @id_db_type
+        @belongs_to_fields["#{f.split(":").last.singularize}_id"] = @id_db_type
+      when "has_many" then @has_many << f.split(":").last.pluralize
+      when "many_to_many" then @many_to_many << f.split(":").last.pluralize
       else
-        hash[f.split(':').first] = f.split(':').last
+        hash[f.split(":").first] = f.split(":").last
       end
     end
 
     @fields_to_migration = @args.map do |f|
-      "t.#{f.reverse.join(' :')}"
+      "t.#{f.reverse.join(" :")}"
     end.join("\n      ")
   end
 
@@ -90,7 +89,7 @@ class GraphqlResourceGenerator < Rails::Generators::NamedBase
     File.write(
       migration_file,
       <<~STRING
-        class Create#{resource.camelize} < ActiveRecord::Migration[5.2]
+        class Create#{resource.camelize} < ActiveRecord::Migration[7.0]
           def change
             create_table :#{resource.pluralize}, id: :uuid do |t|
               #{fields}
@@ -110,33 +109,20 @@ class GraphqlResourceGenerator < Rails::Generators::NamedBase
     generate_graphql_input_type(resource) if options.graphql_input_type?
   end
 
-  def generate_graphql_connection(resource)
-    File.write(
-      "#{graphql_resource_directory(resource)}/connection.rb",
-      <<~STRING
-        #{resource_class(resource)}::Connection = #{resource.pluralize.camelize}::Type.define_connection do
-          name '#{resource.camelize}Connection'
-
-          field :total_count, types.Int do
-            resolve ->(obj, _, _) { obj.nodes.count }
-          end
-        end
-      STRING
-    )
-  end
-
   def generate_graphql_input_type(resource)
     FileUtils.mkdir_p(@mutations_directory) unless File.directory?(@mutations_directory)
 
     File.write(
       "#{@mutations_directory}/input_type.rb",
       <<~STRING
-        #{resource_class(resource)}::Mutations::InputType = GraphQL::InputObjectType.define do
-          name '#{resource_class(resource).singularize}InputType'
-          description 'Properties for updating a #{resource_class(resource).singularize}'
-
-          #{map_types(input_type: true)}
-
+        module #{resource_class(resource)}
+          module Mutations
+            class InputType < GraphQL::Schema::InputObject
+              graphql_name "#{resource.camelize}InputType"
+              description "Attributes for creating or updating a #{resource}"
+              #{map_types(input_type: true)}
+            end
+          end
         end
       STRING
     )
@@ -146,12 +132,16 @@ class GraphqlResourceGenerator < Rails::Generators::NamedBase
     File.write(
       "#{graphql_resource_directory(resource)}/type.rb",
       <<~STRING
-        #{resource_class(resource)}::Type = GraphQL::ObjectType.define do
-          name '#{resource_class(resource).singularize}'
-          field :id, !#{@id_type}
-          field :created_at, types.String
-          field :updated_at, types.String
-          #{map_types(input_type: false)}
+        module #{resource_class(resource)}
+          class Type < GraphQL::Schema::Object
+            graphql_name "#{resource.camelize}"
+            description "A #{resource}"
+
+            field :id, #{@id_type}, null: false
+            field :created_at, String, null: false
+            field :updated_at, String, null: false
+            #{map_types(input_type: false)}
+          end
         end
       STRING
     )
@@ -168,13 +158,7 @@ class GraphqlResourceGenerator < Rails::Generators::NamedBase
       return
     end
     write_at(
-      file_name, 4,
-      <<-STRING
-  field :#{resource.singularize}_ids, types[#{@id_type}] do
-    resolve CollectionIdsResolver
-  end
-  field :#{resource.pluralize}, types[#{resource.pluralize.camelize}::Type]
-        STRING
+      file_name, 6,"    field :#{resource.pluralize}, [#{resource.pluralize.camelize}::Type], null: true\n"
     )
 
     input_type_file_name = "app/graphql/#{field.pluralize}/mutations/input_type.rb"
@@ -183,10 +167,8 @@ class GraphqlResourceGenerator < Rails::Generators::NamedBase
       return
     end
     write_at(
-      input_type_file_name, 4,
-      <<-STRING
-  argument :#{resource.singularize}_ids, types[#{@id_type}]
-      STRING
+      input_type_file_name, 7,
+      "      argument :#{resource.singularize}_ids, [#{@id_type}], required: false\n"
     )
 
   end
@@ -199,11 +181,8 @@ class GraphqlResourceGenerator < Rails::Generators::NamedBase
     end
 
     write_at(
-      file_name, 4,
-      <<-STRING
-  field :#{field.singularize}_id, #{@id_type}
-  field :#{field.singularize}, #{field.pluralize.camelize}::Type
-      STRING
+      file_name, 6,
+      "    field :#{field.singularize}_id, #{@id_type}, null: false\n    field :#{field.singularize}, #{field.pluralize.camelize}::Type, null: false\n"
     )
     input_type_file_name = "app/graphql/#{resource.pluralize}/mutations/input_type.rb"
     if File.read(input_type_file_name).include?("argument :#{field.singularize}_id") ||
@@ -212,10 +191,8 @@ class GraphqlResourceGenerator < Rails::Generators::NamedBase
     end
 
     write_at(
-      input_type_file_name, 4,
-      <<-STRING
-  argument :#{field.singularize}_id, #{@id_type}
-      STRING
+      input_type_file_name, 7,
+      "      argument :#{field.singularize}_id, #{@id_type}, required: false\n"
     )
   end
 
@@ -225,8 +202,8 @@ class GraphqlResourceGenerator < Rails::Generators::NamedBase
       add_belongs_to_field_to_type(resource, f)
     end
     @belongs_to_fields.each do |f, _|
-      add_has_many_fields_to_type(f.gsub('_id', ''), resource)
-      add_belongs_to_field_to_type(f.gsub('_id', ''), resource)
+      add_has_many_fields_to_type(f.gsub("_id", ""), resource)
+      add_belongs_to_field_to_type(f.gsub("_id", ""), resource)
     end
   end
 
@@ -242,9 +219,8 @@ class GraphqlResourceGenerator < Rails::Generators::NamedBase
   end
 
   def generate_service(resource)
-     
     FileUtils.mkdir_p("app/graphql/#{resource.pluralize}/") unless File.directory?("app/graphql/#{resource.pluralize}/")
-     
+
     File.write(
       "app/graphql/#{resource.pluralize}/service.rb",
       <<~STRING
@@ -261,9 +237,9 @@ class GraphqlResourceGenerator < Rails::Generators::NamedBase
     @many_to_many.each do |field|
       generate_create_migration(
         "#{resource}_#{field}",
-        <<-STRING
-t.#{@id_db_type} :#{resource.underscore.singularize}_id
-      t.#{@id_db_type} :#{field.underscore.singularize}_id
+        <<~STRING
+          t.#{@id_db_type} :#{resource.underscore.singularize}_id
+                t.#{@id_db_type} :#{field.underscore.singularize}_id
         STRING
       )
       generate_empty_model("#{resource}_#{field.singularize}")
@@ -285,7 +261,7 @@ t.#{@id_db_type} :#{resource.underscore.singularize}_id
       add_to_model(field, "belongs_to :#{resource.singularize}")
     end
     @belongs_to_fields.each do |k, _|
-      field = k.gsub('_id', '')
+      field = k.gsub("_id", "")
       add_to_model(field, "has_many :#{resource.pluralize}")
       add_to_model(resource, "belongs_to :#{field.singularize}")
     end
@@ -295,14 +271,15 @@ t.#{@id_db_type} :#{resource.underscore.singularize}_id
     result = args&.map do |k, v|
       field_name = k
       field_type = types_mapping(v)
-      res = "#{input_type ? 'argument' : 'field'} :#{field_name}, #{field_type}"
-      if !input_type && field_name.ends_with?('_id') && @belongs_to_fields.key?(field_name)
-        res += "\n  field :#{field_name.gsub('_id', '')}, " \
-          "#{field_name.gsub('_id', '').pluralize.camelize}::Type"
+      res = "#{input_type ? "argument" : "field"} :#{field_name}, #{field_type}, #{input_type ? "required: false" : "null: true"}"
+
+      if !input_type && field_name.ends_with?("_id") && @belongs_to_fields.key?(field_name)
+        res += "\n    field :#{field_name.gsub("_id", "")}, " \
+          "#{field_name.gsub("_id", "").pluralize.camelize}::Type, null: false"
       end
       res
-    end&.join("\n  ")
-    input_type ? result.gsub("field :id, #{@id_type}\n", '') : result
+    end&.join("\n    " + ("  " if input_type).to_s)
+    input_type ? result.gsub("field :id, #{@id_type}, null: false\n", "") : result
   end
 
   # Helpers methods
@@ -312,19 +289,19 @@ t.#{@id_db_type} :#{resource.underscore.singularize}_id
   end
 
   def add_to_model(model, line)
-    file_name = File.join("app","models","#{model.underscore.singularize}.rb")
+    file_name = File.join("app", "models", "#{model.underscore.singularize}.rb")
     return if !File.exist?(file_name) || File.read(file_name).include?(line)
 
     file = open(file_name)
     line_count = file.readlines.size
     line_nb = 0
-    file.each do |l|
+    IO.readlines(file).each do |l|
       line_nb += 1
-      break if l.include?('ApplicationRecord')
+      break if l.include?("ApplicationRecord")
     end
-    raise 'Your model must inherit from ApplicationRecord to make it work' if line_nb >= line_count
+    raise "Your model must inherit from ApplicationRecord to make it work" if line_nb >= line_count
 
-    write_at(file_name, line_nb + 2, "  #{line}\n")
+    write_at(file_name, line_nb + 1, "  #{line}\n")
   end
 
   def generate_has_many_migration(resource, has_many:)
@@ -335,7 +312,7 @@ t.#{@id_db_type} :#{resource.underscore.singularize}_id
     File.write(
       migration_file,
       <<~STRING
-        class Add#{resource.singularize.camelize}IdTo#{has_many.camelize} < ActiveRecord::Migration[5.2]
+        class Add#{resource.singularize.camelize}IdTo#{has_many.camelize} < ActiveRecord::Migration[7.0]
           def change
             add_column :#{has_many.pluralize}, :#{resource.singularize}_id, :#{@id_db_type}
           end
@@ -349,7 +326,7 @@ t.#{@id_db_type} :#{resource.underscore.singularize}_id
   end
 
   def write_at(file_name, line, data)
-    open(file_name, 'r+') do |f|
+    open(file_name, "r+") do |f|
       while (line -= 1).positive?
         f.readline
       end
@@ -360,5 +337,4 @@ t.#{@id_db_type} :#{resource.underscore.singularize}_id
       f.write(rest)
     end
   end
-
 end

data/lib/graphql/hydrate_query.rb

@@ -24,7 +24,7 @@ module Graphql
     def run
       if @id
         @model = @model.where(id: @id)
-        deep_pluck_to_structs(@context&.irep_node).first
+        deep_pluck_to_structs(irep_node(model_name.singularize)).first
       else
         @model = @model.limit(@per_page)
         @model = @model.offset(@per_page * (@page - 1))
@@ -32,7 +32,7 @@ module Graphql
         transform_filter if @filter.present?
         transform_order if @order_by.present?
 
-        deep_pluck_to_structs(@context&.irep_node)
+        deep_pluck_to_structs(irep_node(model_name.pluralize))
       end
     end
 
@@ -45,7 +45,7 @@ module Graphql
       @model = @model.offset(@per_page * (@page - 1))
 
       OpenStruct.new(
-        data: deep_pluck_to_structs(@context&.irep_node&.typed_children&.values&.first.try(:[], "data")),
+        data: deep_pluck_to_structs(irep_node(model_name.pluralize, paginated: true)),
         total_count: @total,
         per_page: @per_page,
         page: @page
@@ -58,7 +58,7 @@ module Graphql
       return if @order_by.blank?
 
       sign = @order_by.split(" ").last.downcase == "desc" ? "desc" : "asc"
-      column = @order_by.split(" ").first.strip
+      column = @order_by.split(" ").first.strip.underscore
 
       if column.include?(".")
         associated_model = column.split(".").first
@@ -120,6 +120,8 @@ module Graphql
         handle_LessNode(node, model)
       elsif node.instance_of?(RKelly::Nodes::GreaterNode)
         handle_GreaterNode(node, model)
+      elsif node.instance_of?(RKelly::Nodes::ModulusNode)
+        handle_ModulusNode(node, model)
       else
         raise GraphQL::ExecutionError, "Invalid filter: #{node.class} unknown operator"
       end
@@ -174,9 +176,17 @@ module Graphql
       if node.instance_of?(RKelly::Nodes::StringNode)
         val = node.value.gsub(/^'|'$|^"|"$/, "")
         if sym_type == :datetime
-          DateTime.parse(val)
+          begin
+            DateTime.parse(val)
+          rescue
+            val
+          end
         elsif sym_type == :date
-          Date.parse(val)
+          begin
+            DateTime.parse(val)
+          rescue
+            val
+          end
         elsif sym_type == :integer
           # Enums are handled here : We are about to compare a string with an integer column
           # If the symbol and the value correspond to an existing enum into the model
@@ -208,6 +218,7 @@ module Graphql
 
     def handle_NotEqualNode(node, model)
       arel_field, model, type, value = handle_operator_node(node, model)
+      arel_field.name = arel_field.name.underscore
 
       if value.nil?
         model.where.not(arel_field.eq(nil))
@@ -220,6 +231,7 @@ module Graphql
 
     def handle_NotStrictEqualNode(node, model)
       arel_field, model, type, value = handle_operator_node(node, model)
+      arel_field.name = arel_field.name.underscore
 
       if value.nil?
         model.where.not(arel_field.eq(nil))
@@ -232,6 +244,7 @@ module Graphql
 
     def handle_EqualNode(node, model)
       arel_field, model, type, value = handle_operator_node(node, model)
+      arel_field.name = arel_field.name.underscore
 
       if value.nil?
         model.where(arel_field.eq(nil))
@@ -244,6 +257,7 @@ module Graphql
 
     def handle_StrictEqualNode(node, model)
       arel_field, model, type, value = handle_operator_node(node, model)
+      arel_field.name = arel_field.name.underscore
 
       if value.nil?
         model.where(arel_field.eq(nil))
@@ -256,24 +270,68 @@ module Graphql
 
     def handle_GreaterOrEqualNode(node, model)
       arel_field, model, type, value = handle_operator_node(node, model)
+      arel_field.name = arel_field.name.underscore
+
       model.where(arel_field.gteq(value))
     end
 
     def handle_LessOrEqualNode(node, model)
       arel_field, model, type, value = handle_operator_node(node, model)
+      arel_field.name = arel_field.name.underscore
+
       model.where(arel_field.lteq(value))
     end
 
     def handle_LessNode(node, model)
       arel_field, model, type, value = handle_operator_node(node, model)
+      arel_field.name = arel_field.name.underscore
+
       model.where(arel_field.lt(value))
     end
 
     def handle_GreaterNode(node, model)
       arel_field, model, type, value = handle_operator_node(node, model)
+      arel_field.name = arel_field.name.underscore
+
       model.where(arel_field.gt(value))
     end
 
+    # Example: "US" should match "US" and "USA" and "AUS"
+    def handle_ModulusNode(node, model)
+      arel_field, model, type, value = handle_operator_node(node, model)
+      arel_field.name = arel_field.name.underscore
+
+      if value.nil?
+        model.where(arel_field.eq(nil))
+      elsif type == :text || type == :string
+        model.where(arel_field.matches("%" + sanitize_sql_like(value) + "%"))
+      elsif type == :datetime
+        if value.instance_of?(DateTime)
+          model.where(arel_field.gteq(value).and(arel_field.lteq(value + 1.day)))
+        else
+          model.where(
+            Arel::Nodes::NamedFunction.new(
+              "CAST",
+              [Arel::Nodes::As.new(arel_field, Arel::Nodes::SqlLiteral.new("text"))]
+            ).matches("%" + sanitize_sql_like(value) + "%")
+          )
+        end
+      elsif type == :uuid
+        model.where(
+          Arel::Nodes::NamedFunction.new(
+            "CAST",
+            [Arel::Nodes::As.new(arel_field, Arel::Nodes::SqlLiteral.new("text"))]
+          ).matches("%" + sanitize_sql_like(value) + "%")
+        )
+      else
+        model.where(arel_field.eq(value))
+      end
+    end
+
+    def uuid_to_string(uuid)
+      uuid.delete("-")
+    end
+
     def valid_id?(id)
       valid_uuid?(id) || id.is_a?(Integer)
     end
@@ -291,7 +349,7 @@ module Graphql
     end
 
     def get_field_type!(model, field_name)
-      field = model.column_for_attribute(field_name.to_sym)
+      field = model.column_for_attribute(field_name.underscore.to_sym)
       unless field.present?
         raise GraphQL::ExecutionError, "Invalid filter: #{field_name} is not a field of #{model}"
       end
@@ -371,13 +429,29 @@ module Graphql
       parent_class_name.constantize.reflections[child.to_s.underscore]&.klass
     end
 
-    def parse_fields(irep_node)
-      fields = irep_node&.scoped_children&.values&.first
-      fields = fields["edges"].scoped_children.values.first["node"]&.scoped_children&.values&.first if fields&.key?("edges")
+    def irep_node(name, paginated: false)
+      child = @context.query.lookahead.ast_nodes.first.children[@context[:query_index]]
+      result = if paginated
+        child.children.find { |n| n.name == "data" }.children
+      else
+        child.children
+      end
+      @context[:query_index] += 1
+      result
+    end
+
+    def parse_fields(global_fields)
+      return if global_fields.blank?
+
+      fields = global_fields.map do |field|
+        next if field.class != GraphQL::Language::Nodes::Field
+        field
+      end.compact
+
       return if fields.blank?
 
-      fields.each_with_object({}) do |(k, v), h|
-        h[k] = v.scoped_children == {} ? v.definition.name : parse_fields(v)
+      fields.each_with_object({}) do |node, h|
+        h[node.name.underscore] = node.children.blank? ? nil : parse_fields(node.children)
       end
     end
 

data/lib/graphql/rails/api/version.rb

@@ -1,7 +1,7 @@
 module Graphql
   module Rails
     module Api
-      VERSION = "0.9.3".freeze
+      VERSION = "0.9.6".freeze
     end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: graphql-rails-api
 version: !ruby/object:Gem::Version
-  version: 0.9.3
+  version: 0.9.6
 platform: ruby
 authors:
 - poilon
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2022-09-06 00:00:00.000000000 Z
+date: 2022-11-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: graphql
@@ -16,20 +16,20 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.12'
+        version: 2.0.15
     - - "<="
       - !ruby/object:Gem::Version
-        version: 1.12.13
+        version: 2.0.15
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.12'
+        version: 2.0.15
     - - "<="
       - !ruby/object:Gem::Version
-        version: 1.12.13
+        version: 2.0.15
 - !ruby/object:Gem::Dependency
   name: deep_pluck_with_authorization
   requirement: !ruby/object:Gem::Requirement
@@ -50,14 +50,14 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 5.1.4
+        version: '0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 5.1.4
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: rkelly-remix
   requirement: !ruby/object:Gem::Requirement