graphql-rails-api 0.6.0 → 0.7.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 066b640b12080a61dc163b4989543cb22cff0c0bc000d5c5f2881ef74a37656a
-  data.tar.gz: '08e978790a84b509ad77c8a0fb58c6d496d891c095092676289c1516fcb478d9'
+  metadata.gz: 8f3e6a19fed3e87964c4c5c50f51a4b9527023484e477f07c5bbed8f6aecd601
+  data.tar.gz: 0c3940236953b52221fc0db3531b11a6e138d9f3f29901abd51dd54016dac92f
 SHA512:
-  metadata.gz: 68ab8d0cc279ca2edebdc20bf3b490b73e8badf3a9f7f0284ef9c3f85c4a1c56ff8f29f8d69d1f16eb7b97e2035e3223308d2f3b093ab5692c40ad560a42cc35
-  data.tar.gz: 44ffdd02ea1cf52065c29db18df694c518ca7b08a9a3264ff25895d702308127265dbce8319ea6e7ce5844df2aeb50f6f3d9c5cdcc4ac0e574675064ab71e58a
+  metadata.gz: c3a5906fc17b0fc02172622dd6e13417fafa3e607a6742fef6dc090b64749bd8d7dc2c12fe49a8760931a0ec91e80f0b91382ca9d854017a90848a0a0ff44e6a
+  data.tar.gz: a9091317f41816ae66c687e952626e2166473e9d488a25ea837c1f57f3f19bac0ee1a1cb14704d3d978ad3e30e463f247fb3097221be920e2b1f9421e8165769

data/lib/generators/graphql_add_fields/graphql_add_fields_generator.rb

@@ -0,0 +1,312 @@
+class GraphqlAddFieldsGenerator < Rails::Generators::NamedBase
+
+  %i[
+    migration model mutations service graphql_input_type
+    graphql_type propagation connection 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'
+  }.freeze
+
+  def create_graphql_files
+    return if args.blank?
+
+    parse_args
+
+    # Generate migration
+    generate_migration(@resource, @fields_to_migration) if options.migration?
+
+    complete_graphql_input_type if options.graphql_input_type?
+
+    # # Graphql Type
+    complete_graphql_type(@resource) if options.graphql_type?
+
+    # # Propagation
+    handle_many_to_many_fields(@resource) if options.propagation?
+    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?
+  end
+
+  private
+
+  def types_mapping(type)
+    TYPES_MAPPING[type] || 'types.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")
+  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")
+  end
+
+  def parse_args
+    @id_db_type = 'uuid'
+    @id_type = 'types.String'
+
+    @resource = file_name.singularize
+    @has_many = []
+    @many_to_many = []
+    @mutations_directory = "#{graphql_resource_directory(@resource)}/mutations"
+    @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
+      else
+        hash[f.split(':').first] = f.split(':').last
+      end
+    end
+
+    @fields_to_migration = @args.map do |f|
+      "add_column :#{@resource.pluralize}, :#{f.join(', :')}"
+    end.join("\n    ")
+    @named_fields = @args.keys.join('_')
+  end
+
+  def generate_migration(resource, fields)
+    return if @named_fields.blank?
+
+    system("bundle exec rails generate migration add_#{@named_fields}_to_#{resource} --skip")
+    File.write(
+      Dir.glob("db/migrate/*add_#{@named_fields}_to_#{resource}.rb").last,
+      <<~STRING
+        class Add#{@named_fields.camelize}To#{resource.camelize} < ActiveRecord::Migration[5.2]
+          def change
+            #{fields}
+          end
+        end
+      STRING
+    )
+  end
+
+  def graphql_resource_directory(resource)
+    "app/graphql/#{resource.pluralize}"
+  end
+
+  def add_has_many_fields_to_type(field, resource)
+    file_name = "app/graphql/#{field.pluralize}/type.rb"
+    if File.read(file_name).include?("field :#{resource.singularize}_ids") ||
+        File.read(file_name).include?("field :#{resource.pluralize}") ||
+        File.read(file_name).include?("connection :#{resource.pluralize}_connection")
+      return
+    end
+
+    write_at(
+      file_name, 4,
+      <<-STRING
+  field :#{resource.singularize}_ids, types[#{@id_type}]
+  field :#{resource.pluralize}, types[#{resource.pluralize.camelize}::Type]
+  connection :#{resource.pluralize}_connection, #{resource.pluralize.camelize}::Connection
+        STRING
+    )
+
+    input_type_file_name = "app/graphql/#{field.pluralize}/mutations/input_type.rb"
+    if File.read(input_type_file_name).include?("argument :#{resource.singularize}_id") ||
+        File.read(input_type_file_name).include?("argument :#{resource.singularize}")
+      return
+    end
+
+    write_at(
+      input_type_file_name, 4,
+      <<-STRING
+  argument :#{resource.singularize}_ids, types[#{@id_type}]
+      STRING
+    )
+  end
+
+  def add_belongs_to_field_to_type(field, resource)
+    file_name = "app/graphql/#{resource.pluralize}/type.rb"
+    if File.read(file_name).include?("field :#{field.singularize}_id") ||
+        File.read(file_name).include?("field :#{field.singularize}")
+      return
+    end
+
+    write_at(
+      file_name, 4,
+      <<-STRING
+  field :#{field.singularize}_id, #{@id_type}
+  field :#{field.singularize}, #{field.pluralize.camelize}::Type
+      STRING
+    )
+    input_type_file_name = "app/graphql/#{resource.pluralize}/mutations/input_type.rb"
+    if File.read(input_type_file_name).include?("argument :#{field.singularize}_id") ||
+        File.read(input_type_file_name).include?("argument :#{field.singularize}")
+      return
+    end
+
+    write_at(
+      input_type_file_name, 4,
+      <<-STRING
+  argument :#{field.singularize}_id, #{@id_type}
+      STRING
+    )
+  end
+
+  def add_has_many_fields_to_types(resource)
+    @has_many.each do |f|
+      add_has_many_fields_to_type(resource, f)
+      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)
+    end
+  end
+
+  def generate_empty_model(resource)
+    File.write(
+      "app/models/#{resource}.rb",
+      <<~STRING
+        class #{resource.singularize.camelize} < ApplicationRecord
+
+        end
+      STRING
+    )
+  end
+
+  def handle_many_to_many_fields(resource)
+    @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
+      )
+      generate_empty_model("#{resource}_#{field.singularize}")
+      add_to_model("#{resource}_#{field.singularize}", "belongs_to :#{resource.singularize}")
+      add_to_model("#{resource}_#{field.singularize}", "belongs_to :#{field.singularize}")
+      add_to_model(resource, "has_many :#{field.pluralize}, through: :#{resource}_#{field.pluralize}")
+      add_to_model(resource, "has_many :#{resource}_#{field.pluralize}")
+      add_to_model(field, "has_many :#{resource.pluralize}, through: :#{resource}_#{field.pluralize}")
+      add_to_model(field, "has_many :#{resource}_#{field.pluralize}")
+      add_has_many_fields_to_type(resource, field)
+      add_has_many_fields_to_type(field, resource)
+    end
+  end
+
+  def add_has_many_to_models(resource)
+    @has_many.each do |field|
+      generate_has_many_migration(resource, has_many: field)
+      add_to_model(resource, "has_many :#{field.pluralize}")
+      add_to_model(field, "belongs_to :#{resource.singularize}")
+    end
+    @belongs_to_fields.each do |k, _|
+      field = k.gsub('_id', '')
+      add_to_model(field, "has_many :#{resource.pluralize}")
+      add_to_model(resource, "belongs_to :#{field.singularize}")
+    end
+  end
+
+  def map_types(input_type: false)
+    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"
+      end
+      res
+    end&.join("\n  ")
+    input_type ? result.gsub("field :id, #{@id_type}\n", '') : result
+  end
+
+  # Helpers methods
+
+  def resource_class(resource)
+    resource.pluralize.camelize
+  end
+
+  def add_to_model(model, line)
+    file_name = "app/models/#{model.underscore.singularize}.rb"
+    return if !File.exist?(file_name) || File.read(file_name).include?(line)
+
+    line_count = `wc -l "#{file_name}"`.strip.split(' ')[0].to_i
+
+    line_nb = 0
+    File.open(file_name).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")
+  end
+
+  def generate_has_many_migration(resource, has_many:)
+    return if has_many.singularize.camelize.constantize.new.respond_to?("#{resource.singularize}_id")
+
+    system("bundle exec rails generate migration add_#{resource.singularize}_id_to_#{has_many}")
+    migration_file = Dir.glob("db/migrate/*add_#{resource.singularize}_id_to_#{has_many}.rb").last
+    File.write(
+      migration_file,
+      <<~STRING
+        class Add#{resource.singularize.camelize}IdTo#{has_many.camelize} < ActiveRecord::Migration[5.2]
+          def change
+            add_column :#{has_many.pluralize}, :#{resource.singularize}_id, :#{@id_db_type}
+          end
+        end
+      STRING
+    )
+  end
+
+  def generate_create_migration(resource, fields)
+    system("bundle exec rails generate migration create_#{resource} --skip")
+    migration_file = Dir.glob("db/migrate/*create_#{resource}.rb").last
+    File.write(
+      migration_file,
+      <<~STRING
+        class Create#{resource.camelize} < ActiveRecord::Migration[5.2]
+          def change
+            create_table :#{resource.pluralize}, id: :uuid do |t|
+              #{fields}
+              t.timestamps
+            end
+          end
+        end
+      STRING
+    )
+  end
+
+  def generate_belongs_to_migration(resource, belongs_to:)
+    generate_has_many_migration(belongs_to, has_many: resource)
+  end
+
+  def write_at(file_name, line, data)
+    open(file_name, 'r+') do |f|
+      while (line -= 1).positive?
+        f.readline
+      end
+      pos = f.pos
+      rest = f.read
+      f.seek(pos)
+      f.write(data)
+      f.write(rest)
+    end
+  end
+
+end

data/lib/generators/graphql_mutations/graphql_mutations_generator.rb

@@ -1,7 +1,6 @@
 class GraphqlMutationsGenerator < Rails::Generators::NamedBase
 
   def generate
-    @id = Graphql::Rails::Api::Config.instance.id_type == :uuid ? '!types.String' : '!types.ID'
     resource = file_name.underscore.singularize
     dir = "app/graphql/#{resource.pluralize}/mutations"
     system("mkdir -p #{dir}")
@@ -22,7 +21,7 @@ class GraphqlMutationsGenerator < Rails::Generators::NamedBase
           description 'creates some #{resource_class(resource).pluralize}'
           type types[#{resource_class(resource)}::Type]
 
-          argument :#{resource}, types[#{resource_class(resource)}::Mutations::InputType]
+          argument :#{resource}, !types[#{resource_class(resource)}::Mutations::InputType]
 
           resolve ApplicationService.call(:#{resource}, :bulk_create)
         end
@@ -38,7 +37,7 @@ class GraphqlMutationsGenerator < Rails::Generators::NamedBase
           description 'Updates some #{resource_class(resource).pluralize}'
           type types[#{resource_class(resource)}::Type]
 
-          argument :#{resource}, types[#{resource_class(resource)}::Mutations::InputType]
+          argument :#{resource}, !types[#{resource_class(resource)}::Mutations::InputType]
 
           resolve ApplicationService.call(:#{resource}, :bulk_update)
         end
@@ -54,7 +53,7 @@ class GraphqlMutationsGenerator < Rails::Generators::NamedBase
           description 'Creates a #{resource_class(resource).singularize}'
           type #{resource_class(resource)}::Type
 
-          argument :#{resource}, #{resource_class(resource)}::Mutations::InputType
+          argument :#{resource}, !#{resource_class(resource)}::Mutations::InputType
 
           resolve ApplicationService.call(:#{resource}, :create)
         end
@@ -70,8 +69,8 @@ class GraphqlMutationsGenerator < Rails::Generators::NamedBase
           description 'Updates a #{resource_class(resource).singularize}'
           type #{resource_class(resource)}::Type
 
-          argument :id, #{@id}
-          argument :#{resource}, #{resource_class(resource)}::Mutations::InputType
+          argument :id, types.String
+          argument :#{resource}, !#{resource_class(resource)}::Mutations::InputType
 
           resolve ApplicationService.call(:#{resource}, :update)
         end
@@ -87,7 +86,7 @@ class GraphqlMutationsGenerator < Rails::Generators::NamedBase
           description 'Destroys a #{resource_class(resource).singularize}'
           type #{resource_class(resource)}::Type
 
-          argument :id, #{@id}
+          argument :id, !types.String
 
           resolve ApplicationService.call(:#{resource}, :destroy)
         end

data/lib/generators/graphql_rails_api/install_generator.rb

@@ -4,41 +4,50 @@ module GraphqlRailsApi
   class InstallGenerator < Rails::Generators::Base
 
     class_option('apollo_compatibility', type: :boolean, default: true)
-    class_option('action_cable_subs', type: :boolean, default: true)
-    class_option('pg_uuid', 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
       system('mkdir -p app/graphql/')
 
+      write_uuid_extensions_migration
+
       write_service
-      write_application_record_methods
       write_schema
       write_query_type
       write_mutation_type
-      write_subscription_type
+
       write_controller
-      if options.action_cable_subs?
-        write_websocket_connection
-        write_online_users_channel
-      end
+
+      write_websocket_models
+      write_websocket_connection
+      write_subscriptions_channel
+
+      write_application_record_methods
       write_initializer
       write_require_application_rb
       write_route if options.generate_graphql_route?
-      write_uuid_extensions_migration if options.pg_uuid?
     end
 
     private
 
+    def write_websocket_models
+      system 'rails g graphql_resource user first_name:string last_name:string email:string'
+      system 'rails g graphql_resource websocket_connection belongs_to:user connection_identifier:string'
+      system 'rails g graphql_resource subscribed_query belongs_to:websocket_connection result_hash:string query:string'
+    end
+
     def write_route
       route_file = File.read('config/routes.rb')
       return if route_file.include?('graphql')
+
       File.write(
         'config/routes.rb',
         route_file.gsub(
           "Rails.application.routes.draw do\n",
-          "Rails.application.routes.draw do\n  post '/graphql', to: 'graphql#execute'\n"
+          "Rails.application.routes.draw do\n" \
+          "  post '/graphql', to: 'graphql#execute'\n" \
+          "  mount ActionCable.server => '/cable'\n"
         )
       )
     end
@@ -60,43 +69,17 @@ module GraphqlRailsApi
     all
   end
 
-        STRING
-      )
-      return unless options.action_cable_subs?
+  def self.broadcast_queries
+    WebsocketConnection.all.each do |wsc|
+      wsc.subscribed_queries.each do |sq|
+        result = #{@app_name.camelize}Schema.execute(sq.query, context: { current_user: wsc.user })
+        hex = Digest::SHA1.hexdigest(result.to_s)
+        next if sq.result_hash == hex
 
-      lines_count = File.read('app/models/application_record.rb').lines.count
-      write_at(
-        'app/models/application_record.rb',
-        lines_count,
-        <<-STRING
-  after_commit :notify_online_users
-
-  def notify_online_users
-    Redis.current.keys('#{Rails.application.class.parent_name.underscore}_subscribed_query_*').each_with_object({}) do |key, hash|
-      hash[
-        key.gsub('#{Rails.application.class.parent_name.underscore}_subscribed_query_', '')
-      ] = Redis.current.hgetall(key).each_with_object([]) do |(data, vars), array|
-        data = data.split('/////')
-        array << { query: data[0], store: data[1], variables: vars.blank? ? nil : JSON.parse(vars), scope: data[2] }
+        sq.update_attributes(result_hash: hex)
+        SubscriptionsChannel.broadcast_to(wsc, query: sq.query, result: result.to_s)
       end
-    end.each do |user_id, user_queries_array|
-      user_queries_array.map { |user_hash| notify_user(user_id, user_hash) }
-    end
-  end
-
-  def notify_user(user_id, user_hash)
-    model_name = self.class.to_s.underscore
-    if !user_hash[:query].include?(model_name.singularize + '(id: $id') &&
-        !user_hash[:query].include?(' ' + model_name.pluralize)
-      return
     end
-    return if user_hash[:query].include?(model_name + '(id: $id') && user_hash[:variables]['id'] != id
-
-    u = User.find_by(id: user_id)
-    return unless u
-
-    result = #{Rails.application.class.parent_name}ApiSchema.execute(user_hash[:query], context: { current_user: u }, variables: user_hash[:variables])
-    OnlineUsersChannel.broadcast_to(u, store: user_hash[:store], scope: user_hash[:scope], result: result['data'])
   end
 
         STRING
@@ -104,11 +87,7 @@ module GraphqlRailsApi
     end
 
     def write_require_application_rb
-      write_at(
-        'config/application.rb',
-        5,
-        "require 'graphql/hydrate_query'\n"
-      )
+      write_at('config/application.rb', 5, "require 'graphql/hydrate_query'\nrequire 'rkelly'\n")
     end
 
     def write_uuid_extensions_migration
@@ -117,7 +96,7 @@ module GraphqlRailsApi
       File.write(
         migration_file,
         <<~STRING
-          class UuidPgExtensions < ActiveRecord::Migration[5.1]
+          class UuidPgExtensions < ActiveRecord::Migration[5.2]
 
             def change
               execute 'CREATE EXTENSION "pgcrypto" SCHEMA pg_catalog;'
@@ -136,8 +115,6 @@ module GraphqlRailsApi
           require 'graphql/rails/api/config'
 
           config = Graphql::Rails::Api::Config.instance
-
-          config.id_type = #{options.pg_uuid? ? ':uuid' : ':id'} # :id or :uuid
         STRING
       )
     end
@@ -149,11 +126,13 @@ module GraphqlRailsApi
           module ApplicationCable
             class Connection < ActionCable::Connection::Base
 
-              identified_by :current_user
+              identified_by :websocket_connection
 
               def connect
                 # Check authentication, and define current user
-                self.current_user = nil
+                self.websocket_connection = WebsocketConnection.create(
+                  # user_id: current_user.id
+                )
               end
 
             end
@@ -162,40 +141,39 @@ module GraphqlRailsApi
       )
     end
 
-    def write_online_users_channel
+    def write_subscriptions_channel
       File.write(
-        'app/channels/online_users_channel.rb',
+        'app/channels/subscriptions_channel.rb',
         <<~STRING
-          class OnlineUsersChannel < ApplicationCable::Channel
+          class SubscriptionsChannel < ApplicationCable::Channel
 
             def subscribed
-              stream_for(current_user)
-              Redis.current.hset('#{Rails.application.class.parent_name.underscore}_online_users', current_user.id, '1')
-              User.online.each do |user|
-                OnlineUsersChannel.broadcast_to(user, User.online_user_ids)
+              stream_for(websocket_connection)
+              websocket_connection.update_attributes(connection_identifier: connection.connection_identifier)
+              ci = ActionCable.server.connections.map(&:connection_identifier)
+              WebsocketConnection.all.each do |wsc|
+                wsc.destroy unless ci.include?(wsc.connection_identifier)
               end
             end
 
             def subscribe_to_query(data)
-              Redis.current.hset(
-                '#{Rails.application.class.parent_name.underscore}_subscribed_query_' + current_user.id,
-                data['query'] + '/////' + data['store'] + '/////' + data['scope'],
-                data['variables']
+              websocket_connection.subscribed_queries.find_or_create_by(query: data['query'])
+              SubscriptionsChannel.broadcast_to(
+                websocket_connection,
+                query: data['query'],
+                result: #{@app_name.camelize}Schema.execute(data['query'], context: { current_user: websocket_connection.user })
               )
             end
 
             def unsubscribe_to_query(data)
-              Redis.current.hdel(
-                '#{Rails.application.class.parent_name.underscore}_subscribed_query_' + current_user.id,
-                data['query'] + '/////' + data['store']
-              )
+              websocket_connection.subscribed_queries.find_by(query: data['query'])&.destroy
             end
 
             def unsubscribed
-              Redis.current.hset('#{Rails.application.class.parent_name.underscore}_online_users', current_user.id, '0')
-              Redis.current.hdel('#{Rails.application.class.parent_name.underscore}_subscribed_query_' + current_user.id, current_user.id)
-              User.online.each do |user|
-                OnlineUsersChannel.broadcast_to(user, User.online_user_ids)
+              websocket_connection.destroy
+              ci = ActionCable.server.connections.map(&:connection_identifier)
+              WebsocketConnection.all.each do |wsc|
+                wsc.destroy unless ci.include?(wsc.connection_identifier)
               end
             end
 
@@ -219,6 +197,7 @@ module GraphqlRailsApi
                 context: { current_user: authenticated_user },
                 operation_name: params[:operationName]
               )
+              ApplicationRecord.broadcast_queries
               render json: result
             end
 
@@ -226,9 +205,6 @@ module GraphqlRailsApi
 
             def authenticated_user
               # Here you need to authenticate the user.
-              # You can use devise, then just write:
-
-              # current_user
             end
 
             # Handle form data, JSON body, or a blank value
@@ -250,17 +226,6 @@ module GraphqlRailsApi
       )
     end
 
-    def write_subscription_type
-      File.write(
-        'app/graphql/subscription_type.rb',
-        <<~STRING
-          SubscriptionType = GraphQL::ObjectType.define do
-            name 'Subscription'
-          end
-        STRING
-      )
-    end
-
     def write_mutation_type
       File.write(
         'app/graphql/mutation_type.rb',
@@ -291,14 +256,14 @@ module GraphqlRailsApi
 
             Graphql::Rails::Api::Config.query_resources.each do |resource|
               field resource.singularize do
-                description "Return a #{resource.classify}"
+                description "Returns a #{resource.classify}"
                 type !"#{resource.camelize}::Type".constantize
                 argument :id, !types.String
                 resolve ApplicationService.call(resource, :show)
               end
 
               field resource.pluralize do
-                description "Return a #{resource.classify}"
+                description "Returns a #{resource.classify}"
                 type !types[!"#{resource.camelize}::Type".constantize]
                 argument :page, types.Int
                 argument :per_page, types.Int
@@ -307,6 +272,11 @@ module GraphqlRailsApi
 
             end
 
+            field :me, Users::Type do
+              description 'Returns the current user'
+              resolve ->(_, _, ctx) { ctx[:current_user] }
+            end
+
           end
         STRING
       )
@@ -352,8 +322,6 @@ module GraphqlRailsApi
             mutation(MutationType)
             query(QueryType)
             #{'directives [ConnectionDirective, ClientDirective]' if options.apollo_compatibility?}
-            #{'use GraphQL::Subscriptions::ActionCableSubscriptions' if options.action_cable_subs?}
-            subscription(SubscriptionType)
             type_error lambda { |err, query_ctx|
               #{error_handler}
             }
@@ -389,76 +357,86 @@ module GraphqlRailsApi
             end
 
             def index
-              HydrateQuery.new(
+              Graphql::HydrateQuery.new(
                 model.all,
                 @context,
                 order_by: params[:order_by],
                 filter: params[:filter],
                 user: user
-              ).run
+              ).run.compact
             end
 
             def show
-              return not_allowed if access_not_allowed
-
-              showed_resource = HydrateQuery.new(model.all, @context, user: user, id: object.id).run
-
-              return not_allowed if showed_resource.blank?
+              object = Graphql::HydrateQuery.new(model.all, @context, user: user, id: params[:id]).run
+              return not_allowed if object.blank?
 
-              showed_resource
+              object
             end
 
             def create
-              if user&.action?("can_create_#{singular_resource}")
-                created_resource = model.new(params.select { |p| model.new.respond_to?(p) })
-                return not_allowed if not_allowed_to_create_resource(created_resource)
-
-                created_resource.save ? created_resource : graphql_error(created_resource.errors.full_messages.join(', '))
-              elsif user&.action?("can_create_#{singular_resource}_with_verif")
-                Verification.create(action: 'create', model: model.to_s, params: params, user_id: user.id)
-                graphql_error("Pending verification for a #{singular_resource} creation")
+              object = model.new(params.select { |p| model.new.respond_to?(p) })
+              return not_allowed if not_allowed_to_create_resource(object)
+
+              if object.save
+                object
               else
-                not_allowed
+                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 user.action?("can_update_#{singular_resource}")
-                object.update_attributes(params) ? object : graphql_error(object.errors.full_messages.join(', '))
-              elsif user.action?("can_update_#{singular_resource}_with_verif")
-                create_update_verification
+              if object.update_attributes(params)
+                object
               else
-                not_allowed
+                graphql_error(object.errors.full_messages.join(', '))
               end
             end
 
             def destroy
-              return not_allowed if write_not_allowed || !user.action?("can_delete_#{singular_resource}")
+              object = model.find_by(id: params[:id])
+              return not_allowed if write_not_allowed
 
-              object.destroy ? object : graphql_error(object.errors.full_messages.join(', '))
+              if object.destroy
+                object
+              else
+                graphql_error(object.errors.full_messages.join(', '))
+              end
             end
 
             private
 
-            def create_update_verification
-              Verification.create(
-                action: 'update', model: model.to_s, params: params.merge(id: object.id), user_id: user.id
-              )
-              graphql_error("Pending verification for a #{singular_resource} update")
-            end
-
             def write_not_allowed
-              return true unless object
-
-              !model.writable_for(user: user).pluck(:id).include?(object.id)
+              !model.visible_for(user: user).include?(object) if object
             end
 
             def access_not_allowed
-              return true unless object
-
-              !model.visible_for(user: user).pluck(:id).include?(object.id)
+              !model.visible_for(user: user).include?(object) if object
             end
 
             def not_allowed
@@ -497,11 +475,15 @@ module GraphqlRailsApi
 
           end
 
-
         STRING
       )
     end
 
+
+    def append(file_name)
+
+    end
+
     def write_at(file_name, line, data)
       open(file_name, 'r+') do |f|
         while (line -= 1).positive?

data/lib/generators/graphql_resource/graphql_resource_generator.rb

@@ -8,7 +8,7 @@ class GraphqlResourceGenerator < Rails::Generators::NamedBase
   end
 
   TYPES_MAPPING = {
-    'id' => 'types.ID',
+    'id' => 'types.String',
     'uuid' => 'types.String',
     'boolean' => 'types.Boolean',
     'float' => 'types.Float',
@@ -55,13 +55,8 @@ class GraphqlResourceGenerator < Rails::Generators::NamedBase
   end
 
   def parse_args
-    if Graphql::Rails::Api::Config.instance.id_type == :uuid
-      @id_db_type = 'uuid'
-      @id_type = 'types.String'
-    else
-      @id_db_type = 'integer'
-      @id_type = 'types.ID'
-    end
+    @id_db_type = 'uuid'
+    @id_type = 'types.String'
 
     @resource = file_name.singularize
     @has_many = []
@@ -100,7 +95,7 @@ class GraphqlResourceGenerator < Rails::Generators::NamedBase
       <<~STRING
         class Create#{resource.camelize} < ActiveRecord::Migration[5.2]
           def change
-            create_table :#{resource.pluralize}, #{'id: :uuid ' if Graphql::Rails::Api::Config.instance.id_type == :uuid}do |t|
+            create_table :#{resource.pluralize}, id: :uuid do |t|
               #{fields}
               t.timestamps
             end

data/lib/graphql/hydrate_query.rb

@@ -4,13 +4,12 @@ require 'rkelly'
 module Graphql
   class HydrateQuery
 
-    def initialize(model, context, order_by: nil, filter: nil, check_visibility: true, id: nil, user: nil)
+    def initialize(model, context, order_by: nil, filter: nil, id: nil, user: nil)
       @context = context
       @filter = filter
       @order_by = order_by
       @model = model
       @models = [model_name.singularize.camelize]
-      @check_visibility = check_visibility
       @id = id
       @user = user
     end
@@ -19,14 +18,17 @@ module Graphql
       @model = @model.where(transform_filter(@filter)) if @filter
       @model = @model.order(@order_by) if @order_by
       @model = @model.where(id: @id) if @id
-      plucked = @model.deep_pluck(*hash_to_array_of_hashes(parse_fields(@context&.irep_node), @model))
+      plucked = DeepPluck::Model.new(@model.visible_for(user: @user), user: @user).add(
+        hash_to_array_of_hashes(parse_fields(@context&.irep_node), @model)
+      ).load_all
       result = plucked_attr_to_structs(plucked, model_name.singularize.camelize.constantize)&.compact
       @id ? result.first : result
     end
 
     def transform_filter(filter)
-      parsed_filter = RKelly::Parser.new.parse(filter).to_ecma
-      parsed_filter.gsub('||', 'OR').gsub('&&', 'AND').gsub('===', '=').gsub('==', '=').delete(';')
+      parsed_filter = RKelly::Parser.new.parse(filter.gsub('like', ' | ')).to_ecma
+      parsed_filter.gsub(' | ', ' like ').
+        gsub('||', 'OR').gsub('&&', 'AND').gsub('===', '=').gsub('==', '=').delete(';')
     end
 
     def plucked_attr_to_structs(arr, parent_model)
@@ -34,13 +36,9 @@ module Graphql
     end
 
     def hash_to_struct(hash, parent_model)
-      if @check_visibility &&
-          (visibility_hash[parent_model].blank? || !visibility_hash[parent_model].include?(hash['id']))
-        return
-      end
-
       hash.each_with_object(OpenStruct.new) do |(k, v), struct|
         m = evaluate_model(parent_model, k)
+
         next struct[k.to_sym] = plucked_attr_to_structs(v, m) if v.is_a?(Array) && m
 
         next struct[k.to_sym] = hash_to_struct(v, m) if v.is_a?(Hash) && m
@@ -49,15 +47,6 @@ module Graphql
       end
     end
 
-    def visibility_hash
-      @visibility_hash ||= @models.reject(&:blank?).each_with_object({}) do |model, hash|
-        visible_ids = model.constantize.visible_for(user: @user)&.pluck(:id)
-        next if visible_ids.blank?
-
-        hash[model.constantize] = visible_ids
-      end
-    end
-
     def hash_to_array_of_hashes(hash, parent_class)
       return if parent_class.nil? || hash.nil?
 
@@ -66,6 +55,7 @@ module Graphql
 
       hash.each_with_object([]) do |(k, v), arr|
         next arr << k if parent_class.new.attributes.key?(k)
+        next arr << v if parent_class.new.attributes.key?(v)
 
         klass = evaluate_model(parent_class, k)
         @models << klass.to_s unless @models.include?(klass.to_s)
@@ -94,8 +84,11 @@ module Graphql
     end
 
     def evaluate_model(parent, child)
-      child_class_name = child.to_s.singularize.camelize
+      return unless parent.reflect_on_association(child)
+
+      child_class_name = parent.reflect_on_association(child).class_name
       parent_class_name = parent.to_s.singularize.camelize
+
       return child_class_name.constantize if activerecord_model?(child_class_name)
 
       return unless activerecord_model?(parent_class_name)
@@ -111,7 +104,7 @@ module Graphql
       return if fields.blank?
 
       fields.each_with_object({}) do |(k, v), h|
-        h[k] = v.scoped_children == {} ? nil : parse_fields(v)
+        h[k] = v.scoped_children == {} ? v.definition.name : parse_fields(v)
       end
     end
 

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

@@ -4,7 +4,6 @@ module Graphql
       class Config
 
         include Singleton
-        attr_accessor :id_type
 
         def self.query_resources
           Dir.glob("#{File.expand_path('.')}/app/graphql/*/type.rb").map do |dir|

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

@@ -1,7 +1,7 @@
 module Graphql
   module Rails
     module Api
-      VERSION = '0.6.0'.freeze
+      VERSION = '0.7.2'.freeze
     end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: graphql-rails-api
 version: !ruby/object:Gem::Version
-  version: 0.6.0
+  version: 0.7.2
 platform: ruby
 authors:
 - poilon
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-12-04 00:00:00.000000000 Z
+date: 2019-02-14 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: graphql
@@ -25,25 +25,19 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '1.7'
 - !ruby/object:Gem::Dependency
-  name: deep_pluck
+  name: deep_pluck_with_authorization
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.1'
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: 1.1.0
+        version: 1.1.2
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.1'
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: 1.1.0
+        version: 1.1.2
 - !ruby/object:Gem::Dependency
   name: rails
   requirement: !ruby/object:Gem::Requirement
@@ -89,7 +83,8 @@ files:
 - MIT-LICENSE
 - README.md
 - Rakefile
-- lib/generators/graphql_connections/graphql_all_connections_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