graphql-rails-api 0.1.3

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 106d6fbb14638d87cf01f586da3eac910f9287e7
+  data.tar.gz: 4ce1326fb1e76cb6ca8d9ea265fc6f817f08edae
+SHA512:
+  metadata.gz: 233e224a5adbdbfe1e40c7cb1e21e892a1846c4df5dbd7fe25665573fb6c0c78167fdf9f71807a5cfa61609c46df8d7daacfb9637252f8bd642fca9af11e1b0f
+  data.tar.gz: 2a5134db639e3659c46859603f9aabf912385e14d713369db9da1ee24c6955fe13e6a90b8620f409e22d708eab551f4dc9913406135070d5bc166cc2af40ed85

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright 2018 poilon
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,37 @@
+# GraphqlRailsApi
+
+`graphql-rails-api` is a gem that provide generators to describe easily your graphql API.
+
+## Installation
+Add these lines to your application's Gemfile:
+
+```ruby
+gem 'graphql'
+gem 'graphql-rails-api'
+```
+
+And then execute:
+```bash
+$ bundle
+$ rails generate graphql_rails_api:install
+```
+
+
+## Usage
+
+```bash
+$ rails generate graphql_resource account base_email:string auth_id:string
+$ rails generate graphql_resource user email:string first_name:string last_name:string has_many:users
+$ rails generate graphql_resource computer ref:string description:text belongs_to:user
+$ rails generate graphql_resource motherboard ref:string many_to_many:computers
+
+```
+
+
+
+
+## Contributing
+Contribution directions go here.
+
+## License
+The gem is available as open source under the terms of the [MIT License](http://opensource.org/licenses/MIT).

data/Rakefile

@@ -0,0 +1,33 @@
+begin
+  require 'bundler/setup'
+rescue LoadError
+  puts 'You must `gem install bundler` and `bundle install` to run rake tasks'
+end
+
+require 'rdoc/task'
+
+RDoc::Task.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = 'Graphql::Rails::Api'
+  rdoc.options << '--line-numbers'
+  rdoc.rdoc_files.include('README.md')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+
+
+
+
+
+require 'bundler/gem_tasks'
+
+require 'rake/testtask'
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'test'
+  t.pattern = 'test/**/*_test.rb'
+  t.verbose = false
+end
+
+
+task default: :test

data/lib/generators/graphql_mutations/graphql_mutations_generator.rb

@@ -0,0 +1,68 @@
+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}")
+    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
+        #{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)
+        end
+      STRING
+    )
+  end
+
+  def generate_update_mutation(dir, resource)
+    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, #{@id}
+          argument :#{resource}, #{resource_class(resource)}::Mutations::InputType
+
+          resolve ApplicationService.call(:#{resource}, :update)
+        end
+      STRING
+    )
+  end
+
+  def generate_destroy_mutation(dir, resource)
+    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, #{@id}
+
+          resolve ApplicationService.call(:#{resource}, :destroy)
+        end
+      STRING
+    )
+  end
+
+  def resource_class(resource)
+    @resource_class ||= resource.pluralize.camelize
+  end
+
+end

data/lib/generators/graphql_rails_api/install_generator.rb

@@ -0,0 +1,424 @@
+require 'graphql/rails/api/config'
+
+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)
+
+    def generate_files
+      @app_name = File.basename(Rails.root.to_s).underscore
+      system('mkdir -p app/graphql/')
+
+      write_service
+      write_application_record_methods
+      write_schema
+      write_query_type
+      write_mutation_type
+      write_subscription_type
+      write_controller
+      write_channel if options.action_cable_subs?
+      write_initializer
+      write_require_application_rb
+      write_uuid_extensions_migration if options.pg_uuid?
+    end
+
+    private
+
+    def write_application_record_methods
+      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')
+      write_at(
+        'app/models/application_record.rb',
+        lines_count,
+        <<-STRING
+  def self.visible_for(*)
+    all
+  end
+
+  def self.writable_by(*)
+    all
+  end
+
+        STRING
+      )
+    end
+
+    def write_require_application_rb
+      File.write(
+        'config/application.rb',
+        File.read('config/application.rb').gsub(
+          "require 'rails/all'",
+          "require 'rails/all'\nrequire 'graphql/hydrate_query'\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
+      File.write(
+        migration_file,
+        <<~STRING
+          class UuidPgExtensions < ActiveRecord::Migration[5.1]
+
+            def change
+              execute 'CREATE EXTENSION "pgcrypto" SCHEMA pg_catalog;'
+              execute 'CREATE EXTENSION "uuid-ossp" SCHEMA pg_catalog;'
+            end
+
+          end
+        STRING
+      )
+    end
+
+    def write_initializer
+      File.write(
+        'config/initializers/graphql_rails_api_config.rb',
+        <<~STRING
+          require 'graphql/rails/api/config'
+
+          config = Graphql::Rails::Api::Config.instance
+
+          config.id_type = #{options.pg_uuid? ? ':uuid' : ':id'} # :id or :uuid
+
+          # Possibilites are :create, :update or :destroy
+          config.basic_mutations = %i[create update destroy]
+        STRING
+      )
+    end
+
+    def write_channel
+      File.write(
+        'app/channels/graphql_channel.rb',
+        <<~STRING
+          class GraphqlChannel < ApplicationCable::Channel
+
+            def subscribed
+              @subscription_ids = []
+            end
+
+            # see graphql-ruby from details
+            def execute(data)
+              query, context, variables, operation_name = options_for_execute(data)
+              result = #{@app_name.camelize}Schema.execute(query: query, context: context,
+                                              variables: variables, operation_name: operation_name)
+              payload = { result: result.subscription? ? nil : result.to_h, more: result.subscription?,
+                          errors: result ? result.to_h[:errors] : nil }
+              @subscription_ids << result.context[:subscription_id] if result.context[:subscription_id]
+              transmit(payload)
+            end
+
+            def unsubscribed
+              @subscription_ids.each do |sid|
+                #{@app_name.camelize}Schema.subscriptions.delete_subscription(sid)
+              end
+            end
+
+            def options_for_execute(data)
+              query = data['query']
+              variables = ensure_hash(data['variables'])
+              operation_name = data['operationName']
+              context = { current_user: current_user, channel: self }.
+                        merge(ensure_hash(data['context']).symbolize_keys). # ensure context is filled
+                        merge(variables) # include variables in context too
+              [query, context, variables, operation_name]
+            end
+
+            # Handle form data, JSON body, or a blank value
+            def ensure_hash(ambiguous_param)
+              case ambiguous_param
+              when String
+                ambiguous_param.present? ? ensure_hash(JSON.parse(ambiguous_param)) : {}
+              when Hash, ActionController::Parameters
+                ambiguous_param
+              when nil
+                {}
+              else
+                raise ArgumentError, 'Unexpected parameter: ' + ambiguous_param
+              end
+            end
+
+          end
+        STRING
+      )
+    end
+
+    def write_controller
+      File.write(
+        'app/controllers/graphql_controller.rb',
+        <<~STRING
+          class GraphqlController < ApplicationController
+
+            # GraphQL endpoint
+            def execute
+              result = #{@app_name.camelize}Schema.execute(
+                params[:query],
+                variables: ensure_hash(params[:variables]),
+                context: { current_user: authenticated_user },
+                operation_name: params[:operationName]
+              )
+              render json: result
+            end
+
+            private
+
+            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
+            def ensure_hash(ambiguous_param)
+              case ambiguous_param
+              when String
+                ambiguous_param.present? ? ensure_hash(JSON.parse(ambiguous_param)) : {}
+              when Hash, ActionController::Parameters
+                ambiguous_param
+              when nil
+                {}
+              else
+                raise ArgumentError, 'Unexpected parameter: ' + ambiguous_param
+              end
+            end
+
+          end
+        STRING
+      )
+    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',
+        <<~'STRING'
+          MutationType = GraphQL::ObjectType.define do
+            name 'Mutation'
+
+            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
+                )
+              end
+            end
+
+          end
+        STRING
+      )
+    end
+
+    def write_query_type
+      File.write(
+        'app/graphql/query_type.rb',
+        <<~'STRING'
+          QueryType = GraphQL::ObjectType.define do
+            name 'Query'
+
+            Graphql::Rails::Api::Config.query_resources.each do |resource|
+              field resource.singularize do
+                description "Return 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}"
+                type !types[!"#{resource.camelize}::Type".constantize]
+                argument :page, types.Int
+                argument :per_page, types.Int
+                resolve ApplicationService.call(resource, :index)
+              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")
+      STRING
+
+      error_handler = <<~'STRING'
+        type_error_logger.error "#{err} for #{query_ctx.query.query_string} \
+            with #{query_ctx.query.provided_variables}"
+      STRING
+
+      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?}
+            #{'use GraphQL::Subscriptions::ActionCableSubscriptions' if options.action_cable_subs?}
+            subscription(SubscriptionType)
+            type_error lambda { |err, query_ctx|
+              #{error_handler}
+            }
+          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.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.visible_for(user: @user), @context).run
+            end
+
+            def show
+              puts 'SHOW'
+              object = Graphql::HydrateQuery.new(model.visible_for(user: @user), @context, id: params[:id]).run
+              return not_allowed if object.blank?
+              object
+            end
+
+            def create
+              puts 'CREATE'
+              object = model.new(params.select { |p| model.new.respond_to?(p) })
+              if object.save
+                object
+              else
+                graphql_error(object.errors.full_messages.join(', '))
+              end
+            end
+
+            def destroy
+              puts 'DESTROY'
+              object = model.find_by(id: params[:id])
+              return not_allowed if write_not_allowed
+              if object.destroy
+                object
+              else
+                graphql_error(object.errors.full_messages.join(', '))
+              end
+            end
+
+            def update
+              puts "UPDATE, #{params}, #{object}"
+              return not_allowed if write_not_allowed
+              if object.update_attributes(params)
+                object
+              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
+
+          end
+
+        STRING
+      )
+    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
+end

data/lib/generators/graphql_resource/USAGE

@@ -0,0 +1,8 @@
+Description:
+    Explain the generator
+
+Example:
+    rails generate graphql_resource Thing
+
+    This will create:
+        what/will/it/create

data/lib/generators/graphql_resource/graphql_resource_generator.rb

@@ -0,0 +1,330 @@
+class GraphqlResourceGenerator < Rails::Generators::NamedBase
+
+  %i[migration model mutations service graphql_input_type graphql_type propagation migrate].each do |opt|
+    class_option(opt, type: :boolean, default: true)
+  end
+
+  TYPES_MAPPING = {
+    'id' => '!types.ID',
+    'uuid' => '!types.String',
+    'text' => 'types.String',
+    'datetime' => 'types.String',
+    'integer' => 'types.Int',
+    'json' => 'types.String',
+    'jsonb' => 'types.String'
+  }.freeze
+
+  def create_graphql_files
+    return if args.blank?
+    parse_args
+
+    # Generate migration
+    generate_create_migration(@resource, @fields_to_migration) if options.migration?
+
+    # Graphql Basic mutations
+    generate_basic_mutations(@resource) if options.mutations?
+
+    # Graphql Type
+    generate_graphql_type(@resource) if options.graphql_type?
+
+    # Model
+    generate_model(@resource) if options.model?
+
+    # Service
+    generate_service(@resource) if options.service?
+    handle_many_to_many_fields(@resource) if options.propagation?
+
+    # 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.#{type.capitalize}"
+  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
+
+    @resource = file_name.singularize
+    @has_many = []
+    @many_to_many = []
+    @mutations_directory = "#{graphql_resource_directory(@resource)}/mutations"
+
+    @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
+      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
+
+    @id_fields = @args.select { |k, _| k.end_with?('_id') }
+
+    @fields_to_migration = @args.map do |f|
+      "t.#{f.reverse.join(' :')}"
+    end.join("\n      ")
+  end
+
+  def graphql_resource_directory(resource)
+    "app/graphql/#{resource.pluralize}"
+  end
+
+  def generate_create_migration(resource, fields)
+    system("bundle exec rails generate migration create_#{resource} --skip")
+    migration_file = Dir.glob("db/migrate/*create_#{resource}*").last
+    File.write(
+      migration_file,
+      <<~STRING
+        class Create#{resource.camelize} < ActiveRecord::Migration[5.1]
+          def change
+            create_table :#{resource.pluralize}, #{'id: :uuid ' if Graphql::Rails::Api::Config.instance.id_type == :uuid}do |t|
+              #{fields}
+              t.timestamps
+            end
+          end
+        end
+      STRING
+    )
+  end
+
+  def generate_basic_mutations(resource)
+    system("mkdir -p #{@mutations_directory}")
+    system("rails generate graphql_mutations #{resource}")
+
+    # Graphql Input Type
+    generate_graphql_input_type(resource) if options.graphql_input_type?
+  end
+
+  def generate_graphql_input_type(resource)
+    system("mkdir -p #{@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)}
+
+        end
+      STRING
+    )
+  end
+
+  def generate_graphql_type(resource)
+    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)}
+        end
+      STRING
+    )
+  end
+
+  def generate_model(resource)
+    generate_empty_model(resource)
+  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}")
+      return
+    end
+    write_at(
+      file_name, 4,
+      <<-STRING
+  field :#{resource.singularize}_ids, !types[#{@id_type}]
+  field :#{resource.pluralize}, !types[!#{resource.pluralize.camelize}::Type]
+        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
+    @id_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 generate_service(resource)
+    File.write(
+      "app/graphql/#{resource.pluralize}/service.rb",
+      <<~STRING
+        module #{resource.pluralize.camelize}
+          class Service < ApplicationService
+
+          end
+        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
+    @id_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')
+        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 unless File.exist?(file_name)
+    return if File.read(file_name).include?(line)
+    write_at(file_name, 3, "  #{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}*").last
+    File.write(
+      migration_file,
+      <<~STRING
+        class Add#{resource.singularize.camelize}IdTo#{has_many.camelize} < ActiveRecord::Migration[5.1]
+          def change
+            add_column :#{has_many.pluralize}, :#{resource.singularize}_id, :#{@id_db_type}
+          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/graphql/hydrate_query.rb

@@ -0,0 +1,136 @@
+module Graphql
+  class HydrateQuery
+
+    def initialize(model, context, id: nil)
+      @fields = context&.irep_node&.scoped_children&.values&.first
+      @model = model
+      @id = id
+    end
+
+    def run
+      hash = parse_fields(@fields)
+      selectable_values = transform_to_selectable_values(hash)
+      joins = remove_keys_with_nil_values(Marshal.load(Marshal.dump(hash)))
+      join_model = @model.includes(joins)
+      join_model = join_model.where(id: @id) if @id.present?
+      res2d = pluck_to_hash_with_ids(join_model, pluckable_attributes(selectable_values))
+      joins_with_root = { model_name.to_sym => remove_keys_with_nil_values(Marshal.load(Marshal.dump(hash))) }
+      ir = nest(joins_with_root, res2d).first
+      @id ? ir_to_output(ir).first : ir_to_output(ir)
+    end
+
+    def pluck_to_hash_with_ids(model, keys)
+      keys.each do |k|
+        resource = k.split('.').first
+        keys << "#{resource.pluralize}.id" unless keys.include?("#{resource}.id")
+      end
+      keys = keys.compact.uniq
+      model.pluck(*keys).map do |pa|
+        Hash[keys.zip([pa].flatten)]
+      end
+    end
+
+    def pluckable_attributes(keys)
+      db_attributes = keys.uniq.map { |k| k.gsub(/\..*$/, '') }.uniq.map do |resource|
+        next unless Object.const_defined?(resource.singularize.camelize)
+        resource.singularize.camelize.constantize.new.attributes.keys.map do |attribute|
+          "#{resource}.#{attribute}"
+        end
+      end.flatten.compact
+      keys.select { |e| db_attributes.flatten.include?(e) }.map do |e|
+        split = e.split('.')
+        "#{split.first.pluralize}.#{split.last}"
+      end
+    end
+
+    def ir_to_output(inter_result)
+      model_name = inter_result&.first&.first&.first&.first&.to_s
+      return [] if model_name.blank?
+      if singular?(model_name)
+        ir_node_to_output(inter_result.first)
+      else
+        inter_result.map do |ir_node|
+          ir_node_to_output(ir_node) if ir_node
+        end
+      end
+    end
+
+    def ir_node_to_output(ir_node)
+      t = ir_node[:results].first.each_with_object({}) do |(attribute, v), h|
+        h[attribute.gsub(ir_node.keys.reject { |key| key == :results }.first.first.to_s.pluralize + '.', '')] = v
+      end
+      relations = ir_node.values&.first&.map { |e| e&.first&.first&.first&.first }
+      relations.zip(ir_node[ir_node.keys.reject { |key| key == :results }&.first]).to_h.map do |key, value|
+        res = ir_to_output(value)
+        t[key] = res if value
+        t[key].compact! if t[key].is_a?(Array)
+      end
+      Struct.new(*t.keys.map(&:to_sym)).new(*t.values) if !t.keys.blank? && !t.values.compact.blank?
+    end
+
+    def singular?(string)
+      string.singularize == string
+    end
+
+    def nest(joins, res)
+      joins.map do |relation_name, other_joins|
+        res.group_by do |row|
+          [relation_name, row["#{relation_name.to_s.pluralize}.id"]]
+        end.map do |k, ungrouped|
+          Hash[k, nest(other_joins, ungrouped)].merge(results: extract_values_of_level(k[0], ungrouped).uniq)
+        end
+      end
+    end
+
+    def extract_values_of_level(level, ungrouped)
+      ungrouped.map do |row|
+        row.select { |k, _| k =~ /#{level.to_s.pluralize}.*/ }
+      end
+    end
+
+    def transform_to_selectable_values(hash, res = nil)
+      @values ||= []
+      hash.each do |k, v|
+        if v.nil?
+          @values << "#{res || model_name}.#{k}" unless activerecord_model?(k)
+        else
+          next @values << "#{res || model_name}.#{k}" unless activerecord_model?(k)
+          transform_to_selectable_values(v, k)
+        end
+      end
+      @values
+    end
+
+    def remove_keys_with_nil_values(hash)
+      hash.symbolize_keys!
+      hash.each_key do |k|
+        if hash[k].nil? || !activerecord_model?(k)
+          hash.delete(k)
+        else
+          remove_keys_with_nil_values(hash[k])
+        end
+      end
+    end
+
+    def parse_fields(fields)
+      fields.each_with_object({}) do |(k, v), h|
+        next if k == '__typename'
+        h[k] = v.scoped_children == {} ? nil : parse_fields(v.scoped_children.values.first)
+      end
+    end
+
+    def model_name
+      @model.class.to_s.split('::').first.underscore.pluralize
+    end
+
+    def activerecord_model?(name)
+      class_name = name.to_s.singularize.camelize
+      begin
+        class_name.constantize.ancestors.include?(ApplicationRecord)
+      rescue NameError
+        false
+      end
+    end
+
+  end
+end

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

@@ -0,0 +1,30 @@
+module Graphql
+  module Rails
+    module Api
+      class Config
+
+        include Singleton
+        attr_accessor :id_type, :basic_mutations
+
+        def self.query_resources
+          Dir.glob("#{File.expand_path('.')}/app/graphql/*/type.rb").map do |dir|
+            dir.split('/').last(2).first
+          end
+        end
+
+        def self.mutation_resources
+          mutations = Dir.glob("#{File.expand_path('.')}/app/graphql/*/mutations/*.rb").reject do |e|
+            e.end_with?('type.rb', 'types.rb')
+          end
+          mutations = mutations.map { |e| e.split('/').last.gsub('.rb', '') }.uniq
+          mutations.each_with_object({}) do |meth, h|
+            h[meth] = Dir.glob("#{File.expand_path('.')}/app/graphql/*/mutations/#{meth}.rb").map do |dir|
+              dir.split('/').last(3).first
+            end
+          end
+        end
+
+      end
+    end
+  end
+end

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

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

data/lib/tasks/graphql/rails/api_tasks.rake

@@ -0,0 +1,4 @@
+# desc "Explaining what the task does"
+# task :graphql_rails_api do
+#   # Task goes here
+# end

metadata

@@ -0,0 +1,84 @@
+--- !ruby/object:Gem::Specification
+name: graphql-rails-api
+version: !ruby/object:Gem::Version
+  version: 0.1.3
+platform: ruby
+authors:
+- poilon
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2018-05-27 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: graphql
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.7'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.7'
+- !ruby/object:Gem::Dependency
+  name: rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.1'
+description: This gem purpose is to make graphql easier to use in ruby. Mainly developed
+  for from-scratch app
+email:
+- poilon@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- MIT-LICENSE
+- README.md
+- Rakefile
+- 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
+- lib/graphql/hydrate_query.rb
+- lib/graphql/rails/api/config.rb
+- lib/graphql/rails/api/version.rb
+- lib/tasks/graphql/rails/api_tasks.rake
+homepage: https://github.com/poilon/graphql-rails-api
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.6.14
+signing_key: 
+specification_version: 4
+summary: Graphql rails api framework to create easily graphql api with rails
+test_files: []