graphql-rails-api 0.9.7 → 0.9.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2eb89c21597bdbc0a59ebe13ec5030d847fd356901600700ae3be29f33c3f54f
-  data.tar.gz: a276f011746654e122e7b574707fa1df57590e753ca64ea3d23e232d2fcb356a
+  metadata.gz: acf07a5b93e2cd63fd09cd0cd8081a5ee75f89e085f48405dfa197e5684f4b72
+  data.tar.gz: 7bb866a32483d31ba22a7283915484154b91f0720dab5fbb6b4477e298b8c670
 SHA512:
-  metadata.gz: bf96a1ce8f8f0d18a7d5ca9844fa3802c84664e05e1a790a257007cfd71444fff823a2b916b0e1e436694e9402edb38a484a1fe58c26b33e9b86ecbd551eee13
-  data.tar.gz: 438629cf1b5213e919639f60b52b2f8f64b02d086578570fc8924bedf770d5826af51506b6191d458dc4ba851839cd11f1abbb44775b3579b993aa336da87056
+  metadata.gz: 2d413ded07452606a26e58d23e7b6e000cf48dfcf990e7b6d68329587ac5e19a0aa7ad6d336fb193ac90a67cf4a2d63573b5dbc9add3a804f05cb26df5ad26a4
+  data.tar.gz: 030c84889982ffc7dc9bbe498079aa418851c314b299f1bec681b56cd6cfc7f12660ddcb24c99d42bbf4fc956a3ecb8f843c57fd039391d3d4f419f52bae8304

data/README.md

@@ -227,24 +227,6 @@ mutation($id: String!) {
 }
 ```
 
-bulk_create mutation:
-```gql
-mutation($cities: [CityInputType]!) {
-  bulk_create_city(cities: $cities) {
-    id
-  }
-}
-```
-
-bulk_update:
-```gql
-mutation($cities: [CityInputType]!) {
-  bulk_update_city(cities: $cities) {
-    id
-  }
-}
-```
-
 You can override the default application service for all mutation by defining your own method into the corresponding graphql service:
 
 Example:

data/lib/generators/auth0_authentication/auth0_authentication_generator.rb

@@ -0,0 +1,4 @@
+class Auth0AuthenticationGenerator < Rails::Generators::NamedBase
+  def create_authentication_files
+  end
+end

data/lib/generators/graphql_add_fields/graphql_add_fields_generator.rb

@@ -1,20 +1,19 @@
 class GraphqlAddFieldsGenerator < 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' => 'String',
-    'uuid' => 'String',
-    'boolean' => 'Boolean',
-    'float' => 'Float',
-    'decimal' => 'Float',
-    'integer' => 'Integer',
-    'bigint' => 'Integer'
+    "id" => "String",
+    "uuid" => "String",
+    "boolean" => "Boolean",
+    "float" => "Float",
+    "decimal" => "Float",
+    "integer" => "Integer",
+    "bigint" => "Integer"
   }.freeze
 
   def create_graphql_files
@@ -41,7 +40,7 @@ class GraphqlAddFieldsGenerator < Rails::Generators::NamedBase
   private
 
   def types_mapping(type)
-    TYPES_MAPPING[type] || 'String'
+    TYPES_MAPPING[type] || "String"
   end
 
   def complete_graphql_input_type
@@ -57,8 +56,8 @@ class GraphqlAddFieldsGenerator < Rails::Generators::NamedBase
   end
 
   def parse_args
-    @id_db_type = 'uuid'
-    @id_type = 'String'
+    @id_db_type = "uuid"
+    @id_type = "String"
 
     @resource = file_name.singularize
     @has_many = []
@@ -67,23 +66,23 @@ class GraphqlAddFieldsGenerator < 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|
-      "add_column :#{@resource.pluralize}, :#{f.join(', :')}"
+      "add_column :#{@resource.pluralize}, :#{f.join(", :")}"
     end.join("\n    ")
-    @named_fields = @args.keys.join('_')
+    @named_fields = @args.keys.join("_")
   end
 
   def generate_migration(resource, fields)
@@ -159,8 +158,8 @@ class GraphqlAddFieldsGenerator < 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
 
@@ -179,9 +178,9 @@ class GraphqlAddFieldsGenerator < 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}")
@@ -203,7 +202,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
@@ -213,14 +212,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}, #{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"
+      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"
       end
       res
     end&.join("\n    " + ("  " if input_type).to_s)
-    input_type ? result.gsub("field :id, #{@id_type}, null: false\n", '') : result
+    input_type ? result.gsub("field :id, #{@id_type}, null: false\n", "") : result
   end
 
   # Helpers methods
@@ -238,9 +237,9 @@ t.#{@id_db_type} :#{resource.underscore.singularize}_id
     line_nb = 0
     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 + 1, "  #{line}\n")
   end
@@ -285,7 +284,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
@@ -296,5 +295,4 @@ t.#{@id_db_type} :#{resource.underscore.singularize}_id
       f.write(rest)
     end
   end
-
 end

data/lib/generators/graphql_rails_api/install_generator.rb

@@ -1,14 +1,13 @@
-require 'graphql/rails/api/config'
+require "graphql/rails/api/config"
 
 module GraphqlRailsApi
   class InstallGenerator < Rails::Generators::Base
-
-    class_option('generate_graphql_route', type: :boolean, default: true)
+    class_option("generate_graphql_route", type: :boolean, default: true)
 
     def generate_files
       @app_name = File.basename(Rails.root.to_s).underscore
 
-      folder = 'app/graphql/'
+      folder = "app/graphql/"
       FileUtils.mkdir_p(folder) unless File.directory?(folder)
 
       write_uuid_extensions_migration
@@ -21,22 +20,23 @@ module GraphqlRailsApi
 
       write_controller
 
-      system 'rails g graphql_resource user first_name:string last_name:string email:string'
+      system "rails g graphql_resource user first_name:string last_name:string email:string"
 
       write_application_record_methods
       write_initializer
       write_require_application_rb
+
       write_route if options.generate_graphql_route?
     end
 
     private
 
     def write_route
-      route_file = File.read('config/routes.rb')
-      return if route_file.include?('graphql')
+      route_file = File.read("config/routes.rb")
+      return if route_file.include?("graphql")
 
       File.write(
-        'config/routes.rb',
+        "config/routes.rb",
         route_file.gsub(
           "Rails.application.routes.draw do\n",
           "Rails.application.routes.draw do\n" \
@@ -47,7 +47,7 @@ module GraphqlRailsApi
 
     def write_collection_ids_resolver
       File.write(
-        'app/graphql/collection_ids_resolver.rb',
+        "app/graphql/collection_ids_resolver.rb",
         <<~STRING
           class CollectionIdsResolver
 
@@ -65,14 +65,13 @@ module GraphqlRailsApi
     end
 
     def write_application_record_methods
-      lines_count = File.read('app/models/application_record.rb').lines.count
+      lines_count = File.read("app/models/application_record.rb").lines.count
 
-      return if File.read('app/models/application_record.rb').include?('def self.visible_for')
+      return if File.read("app/models/application_record.rb").include?("def self.visible_for")
       write_at(
-        'app/models/application_record.rb',
+        "app/models/application_record.rb",
         lines_count,
         <<-STRING
-
   def self.visible_for(*)
     all
   end
@@ -82,17 +81,17 @@ module GraphqlRailsApi
   end
 
 
-  STRING
-  )
-end
+        STRING
+      )
+    end
 
     def write_require_application_rb
-      write_at('config/application.rb', 5, "require 'graphql/hydrate_query'\nrequire 'rkelly'\nrequire 'graphql'\n")
+      write_at("config/application.rb", 5, "require 'graphql/hydrate_query'\nrequire 'rkelly'\nrequire 'graphql'\n")
     end
 
     def write_uuid_extensions_migration
-      system('bundle exec rails generate migration uuid_pg_extensions --skip')
-      migration_file = Dir.glob('db/migrate/*uuid_pg_extensions*').last
+      system("bundle exec rails generate migration uuid_pg_extensions --skip")
+      migration_file = Dir.glob("db/migrate/*uuid_pg_extensions*").last
       File.write(
         migration_file,
         <<~STRING
@@ -109,7 +108,7 @@ end
 
     def write_initializer
       File.write(
-        'config/initializers/graphql_rails_api_config.rb',
+        "config/initializers/graphql_rails_api_config.rb",
         <<~STRING
           require 'graphql/rails/api/config'
 
@@ -120,7 +119,7 @@ end
 
     def write_controller
       File.write(
-        'app/controllers/graphql_controller.rb',
+        "app/controllers/graphql_controller.rb",
         <<~STRING
           class GraphqlController < ApplicationController
 
@@ -162,7 +161,7 @@ end
 
     def write_mutation_type
       File.write(
-        'app/graphql/mutation_type.rb',
+        "app/graphql/mutation_type.rb",
         <<~'STRING'
           class MutationType < GraphQL::Schema::Object
             graphql_name "Mutation"
@@ -183,7 +182,7 @@ end
 
     def write_query_type
       File.write(
-        'app/graphql/query_type.rb',
+        "app/graphql/query_type.rb",
         <<~'STRING'
           class QueryType < GraphQL::Schema::Object
             description "The query root of this schema"
@@ -263,152 +262,152 @@ end
       File.write(
         "app/graphql/#{@app_name}_schema.rb",
         <<~STRING
-          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
+                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
+            )
           end
-        <<~STRING
-      )
-    end
-
-    def write_service
-      File.write(
-        'app/graphql/application_service.rb',
-        <<~'STRING'
-          class ApplicationService
 
-            attr_accessor :params, :object, :fields, :user
-
-            def initialize(params: {}, object: nil, object_id: nil, user: nil, context: nil)
-              @params = params.is_a?(Array) ? params.map { |p| p.to_h.symbolize_keys } : params.to_h.symbolize_keys
-              @context = context
-              @object = object || (object_id && model.visible_for(user: user).find_by(id: object_id))
-              @object_id = object_id
-              @user = user
-            end
-
-            def self.call(resource, meth)
-              lambda { |_obj, args, context|
-                params = args && args[resource] ? args[resource] : args
-                "#{resource.to_s.pluralize.camelize.constantize}::Service".constantize.new(
-                  params: params, user: context[:current_user],
-                  object_id: args[:id], context: context
-                ).send(meth)
-              }
-            end
-
-            def index
-              Graphql::HydrateQuery.new(
-                model.all,
-                @context,
-                order_by: params[:order_by],
-                filter: params[:filter],
-                per_page: params[:per_page],
-                page: params[:page],
-                user: user
-              ).run.compact
-            end
-
-            def show
-              object = Graphql::HydrateQuery.new(model.all, @context, user: user, id: params[:id]).run
-              return not_allowed if object.blank?
-
-              object
-            end
-
-            def create
-              object = model.new(params.select { |p| model.new.respond_to?(p) })
-              return not_allowed if not_allowed_to_create_resource(object)
-
-              if object.save
-                { 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 update
-              return not_allowed if write_not_allowed
-
-              if object.update_attributes(params)
-                { 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 destroy
-              object = model.find_by(id: params[:id])
-              return not_allowed if write_not_allowed
-
-              if object.destroy
-                { singular_resource => object.attributes }
-              else
-                graphql_error(object.errors.full_messages.join(', '))
-              end
-            end
-
-            private
-
-            def write_not_allowed
-              !model.visible_for(user: user).include?(object) if object
-            end
-
-            def access_not_allowed
-              !model.visible_for(user: user).include?(object) if object
-            end
-
-            def not_allowed
-              graphql_error('403 - Not allowed')
-            end
-
-            def graphql_error(message)
-              GraphQL::ExecutionError.new(message)
-            end
-
-            def singular_resource
-              resource_name.singularize
-            end
-
-            def model
-              singular_resource.camelize.constantize
-            end
-
-            def resource_name
-              self.class.to_s.split(':').first.underscore
-            end
-
-            def not_allowed_to_create_resource(created_resource)
-              params.select { |k, _| k.to_s.end_with?('_id') }.each do |belongs_relation, rel_id|
-                klass = created_resource.class.reflect_on_association(belongs_relation.to_s.gsub('_id', '')).klass
-                return true if rel_id.present? && !klass.visible_for(user: user).pluck(:id).include?(rel_id)
-              end
-
-              params.select { |k, _| k.to_s.end_with?('_ids') }.each do |many_relation, rel_ids|
-                klass = created_resource.class.reflect_on_association(many_relation.to_s.gsub('_ids', '').pluralize).klass
-                ids = klass.visible_for(user: user).pluck(:id)
-                rel_ids.each { |id| return true if id.present? && !ids.include?(id) }
-              end
-              false
-            end
-
-          end
+          def write_service
+            File.write(
+              'app/graphql/application_service.rb',
+              <<~'STRING'
+                class ApplicationService
+
+                  attr_accessor :params, :object, :fields, :user
+
+                  def initialize(params: {}, object: nil, object_id: nil, user: nil, context: nil)
+                    @params = params.is_a?(Array) ? params.map { |p| p.to_h.symbolize_keys } : params.to_h.symbolize_keys
+                    @context = context
+                    @object = object || (object_id && model.visible_for(user: user).find_by(id: object_id))
+                    @object_id = object_id
+                    @user = user
+                  end
+
+                  def self.call(resource, meth)
+                    lambda { |_obj, args, context|
+                      params = args && args[resource] ? args[resource] : args
+                      "#{resource.to_s.pluralize.camelize.constantize}::Service".constantize.new(
+                        params: params, user: context[:current_user],
+                        object_id: args[:id], context: context
+                      ).send(meth)
+                    }
+                  end
+
+                  def index
+                    Graphql::HydrateQuery.new(
+                      model.all,
+                      @context,
+                      order_by: params[:order_by],
+                      filter: params[:filter],
+                      per_page: params[:per_page],
+                      page: params[:page],
+                      user: user
+                    ).run.compact
+                  end
+
+                  def show
+                    object = Graphql::HydrateQuery.new(model.all, @context, user: user, id: params[:id]).run
+                    return not_allowed if object.blank?
+
+                    object
+                  end
+
+                  def create
+                    object = model.new(params.select { |p| model.new.respond_to?(p) })
+                    return not_allowed if not_allowed_to_create_resource(object)
+
+                    if object.save
+                      { 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 update
+                    return not_allowed if write_not_allowed
+
+                    if object.update_attributes(params)
+                      { 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 destroy
+                    object = model.find_by(id: params[:id])
+                    return not_allowed if write_not_allowed
+
+                    if object.destroy
+                      { singular_resource => object.attributes }
+                    else
+                      graphql_error(object.errors.full_messages.join(', '))
+                    end
+                  end
+
+                  private
+
+                  def write_not_allowed
+                    !model.visible_for(user: user).include?(object) if object
+                  end
+
+                  def access_not_allowed
+                    !model.visible_for(user: user).include?(object) if object
+                  end
+
+                  def not_allowed
+                    graphql_error('403 - Not allowed')
+                  end
+
+                  def graphql_error(message)
+                    GraphQL::ExecutionError.new(message)
+                  end
+
+                  def singular_resource
+                    resource_name.singularize
+                  end
+
+                  def model
+                    singular_resource.camelize.constantize
+                  end
+
+                  def resource_name
+                    self.class.to_s.split(':').first.underscore
+                  end
+
+                  def not_allowed_to_create_resource(created_resource)
+                    params.select { |k, _| k.to_s.end_with?('_id') }.each do |belongs_relation, rel_id|
+                      klass = created_resource.class.reflect_on_association(belongs_relation.to_s.gsub('_id', '')).klass
+                      return true if rel_id.present? && !klass.visible_for(user: user).pluck(:id).include?(rel_id)
+                    end
+
+                    params.select { |k, _| k.to_s.end_with?('_ids') }.each do |many_relation, rel_ids|
+                      klass = created_resource.class.reflect_on_association(many_relation.to_s.gsub('_ids', '').pluralize).klass
+                      ids = klass.visible_for(user: user).pluck(:id)
+                      rel_ids.each { |id| return true if id.present? && !ids.include?(id) }
+                    end
+                    false
+                  end
+
+                end
 
         STRING
       )
     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
@@ -419,6 +418,5 @@ end
         f.write rest
       end
     end
-
   end
 end

data/lib/graphql/hydrate_query.rb

@@ -451,11 +451,12 @@ module Graphql
     end
 
     def irep_node(name, paginated: false)
-      child = @context.query.lookahead.ast_nodes.first.children[@context[:query_index]]
+      children = @context.query.lookahead.ast_nodes.first.children[@context[:query_index]].children
       result = if paginated
-        child.children.find { |n| n.name == "data" }.children
+        children.find { |n| n.name == "data" }.children
       else
-        child.children
+        prepend = children.find { |n| n.name == model_name.singularize }
+        prepend.present? ? prepend.children : children
       end
       @context[:query_index] += 1
       result
@@ -471,7 +472,7 @@ module Graphql
 
       return if fields.blank?
 
-      fields.each_with_object({}) do |node, h|
+      res = 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.7".freeze
+      VERSION = "0.9.8".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.7
+  version: 0.9.8
 platform: ruby
 authors:
 - poilon
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2022-11-09 00:00:00.000000000 Z
+date: 2022-11-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: graphql
@@ -83,11 +83,8 @@ files:
 - MIT-LICENSE
 - README.md
 - Rakefile
+- lib/generators/auth0_authentication/auth0_authentication_generator.rb
 - lib/generators/graphql_add_fields/graphql_add_fields_generator.rb
-- lib/generators/graphql_all_connections/graphql_all_connections_generator.rb
-- lib/generators/graphql_mutations/graphql_bulk_create_mutations_generator.rb
-- lib/generators/graphql_mutations/graphql_bulk_update_mutations_generator.rb
-- lib/generators/graphql_mutations/graphql_mutations_generator.rb
 - lib/generators/graphql_rails_api/install_generator.rb
 - lib/generators/graphql_resource/USAGE
 - lib/generators/graphql_resource/graphql_resource_generator.rb

data/lib/generators/graphql_all_connections/graphql_all_connections_generator.rb

@@ -1,26 +0,0 @@
-class GraphqlAllConnectionsGenerator < Rails::Generators::NamedBase
-
-  def generate
-    Graphql::Rails::Api::Config.query_resources.each do |resource|
-      dir = "app/graphql/#{resource.pluralize}"
-      generate_connection(dir, resource) if Dir.exist?(dir)
-    end
-  end
-
-  def generate_connection(dir, resource)
-    FileUtils.mkdir_p(dir) unless File.directory?(dir)
-    File.write(
-      "#{dir}/connection.rb",
-      <<~STRING
-        #{resource.pluralize.camelize}::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
-
-end

data/lib/generators/graphql_mutations/graphql_bulk_create_mutations_generator.rb

@@ -1,30 +0,0 @@
-class GraphqlBulkCreateMutationsGenerator < Rails::Generators::NamedBase
-
-  def generate
-    Graphql::Rails::Api::Config.query_resources.each do |resource|
-      dir = "#{Rails.root}/app/graphql/#{resource.pluralize}/mutations"
-      generate_bulk_create_mutation(dir, resource) if Dir.exist?(dir)
-    end
-  end
-
-  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 resource_class(resource)
-    resource.pluralize.camelize
-  end
-
-end

data/lib/generators/graphql_mutations/graphql_bulk_update_mutations_generator.rb

@@ -1,30 +0,0 @@
-class GraphqlBulkUpdateMutationsGenerator < Rails::Generators::NamedBase
-
-  def generate
-    Graphql::Rails::Api::Config.query_resources.each do |resource|
-      dir = "#{Rails.root}/app/graphql/#{resource.pluralize}/mutations"
-      generate_bulk_update_mutation(dir, resource) if Dir.exist?(dir)
-    end
-  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 resource_class(resource)
-    resource.pluralize.camelize
-  end
-
-end

data/lib/generators/graphql_mutations/graphql_mutations_generator.rb

@@ -1,92 +0,0 @@
-class GraphqlMutationsGenerator < Rails::Generators::NamedBase
-  def generate
-    resource = file_name.underscore.singularize
-    dir = "app/graphql/#{resource.pluralize}/mutations"
-    FileUtils.mkdir_p(dir) unless File.directory?(dir)
-    generate_create_mutation(dir, resource)
-    generate_update_mutation(dir, resource)
-    generate_destroy_mutation(dir, resource)
-  end
-
-  private
-
-  def generate_create_mutation(dir, resource)
-    File.write(
-      "#{dir}/create.rb",
-      <<~STRING
-        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
-    )
-  end
-
-  def generate_update_mutation(dir, resource)
-    File.write(
-      "#{dir}/update.rb",
-      <<~STRING
-        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
-    )
-  end
-
-  def generate_destroy_mutation(dir, resource)
-    File.write(
-      "#{dir}/destroy.rb",
-      <<~STRING
-        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
-    )
-  end
-
-  def resource_class(resource)
-    @resource_class ||= resource.pluralize.camelize
-  end
-end