rails-graphql-generator 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 3044f10456b35da92ca114424e35da2ba575993f
+  data.tar.gz: 5701cb9b7a8883bb6021375ea1a3fc41483ac689
+SHA512:
+  metadata.gz: 561be3a2e560815a94912380105d57c214d379a01e37637a93b9e93b1449fa6b0a728108c7de81dfe153048c975648ec4121a570587b69817aed1259a3a7a00c
+  data.tar.gz: b0c9d5a698de7bdb68be0387379c261598b17c577619e46f12bbeceb5a30ac652c255c87d82b4f7f9704a93dfee0917caa5c26c7ab870b4f81c19b43827c03b1

data/lib/generators/graphql/USAGE

@@ -0,0 +1,9 @@
+Description:
+
+
+Example:
+    rails generate graphql Model
+
+    This will create:
+        app/graphql/types/model_type.rb
+        app/graphql/mutations/model_.rb

data/lib/generators/graphql/create_all_generator.rb

@@ -0,0 +1,23 @@
+require 'generators/graphql/graphql_helpers'
+
+module Graphql
+  module Generators
+    class CreateAllGenerator < Rails::Generators::Base
+      source_root File.expand_path('../templates', __FILE__)
+
+      include Graphql::Generators::GraphqlHelpers
+
+      def create
+        models.each { |model| create_type(model) }
+        models.each { |model| add_fields(model) }
+        models.each { |model| add_methods(model) }
+        models.each { |model| add_connections(model) }
+        models.each { |model| add_connection_query(model) }
+        models.each { |model| create_mutation(model) }
+        models.each { |model| add_fields_to_mutation(model) }
+        models.each { |model| add_mutation_query(model) }
+      end
+
+    end
+  end
+end

data/lib/generators/graphql/graphql_generator.rb

@@ -0,0 +1,24 @@
+require 'generators/graphql/graphql_helpers'
+
+module Graphql
+  module Generators
+    class GraphqlGenerator < Rails::Generators::NamedBase
+      source_root File.expand_path('../templates', __FILE__)
+      namespace 'graphql'
+
+      include Graphql::Generators::GraphqlHelpers
+
+      def create
+        model = name.classify.constantize
+        create_type(model)
+        add_fields(model)
+        add_methods(model)
+        add_connections(model)
+        add_connection_query(model)
+        create_mutation(model)
+        add_fields_to_mutation(model)
+        add_mutation_query(model)
+      end
+    end
+  end
+end

data/lib/generators/graphql/graphql_helpers.rb

@@ -0,0 +1,256 @@
+module Graphql
+  module Generators
+    module GraphqlHelpers
+      def models
+        @models ||= ActiveRecord::Base.connection.tables.map{ |x| x.classify.safe_constantize }.compact
+      end
+
+      def type_mapper
+        @type_mapper ||= {
+            integer:  'Int',
+            string:   'String',
+            datetime: 'String',
+            boolean:  'Boolean',
+            float:    'Float',
+            date:     'String',
+            json:     'String',
+            text:     'String',
+            decimal:  'Float',
+            '' =>     'String',
+        }
+      end
+
+      def create_type(model)
+        create_file "app/graphql/types/#{ActiveModel::Naming.singular_route_key(model)}_type.rb", <<-FILE
+#{model.to_s}Type = GraphQL::ObjectType.define do
+  name '#{model.to_s}'
+  description '#{model.to_s} type'
+
+  interfaces [NodeIdentification.interface]
+
+  field :id, field: GraphQL::Relay::GlobalIdField.new('#{model.to_s}')
+  # End of fields
+end
+        FILE
+        add_fields(model)
+      end
+
+      def add_fields(model)
+        columns = model.columns_hash
+        columns.keys.each do |k|
+          next if columns[k].name == 'id'
+
+          if columns[k].type.present?
+            inject_into_file type_path(model), after: "field :id, field: GraphQL::Relay::GlobalIdField.new('#{model.to_s}')\n" do <<-FILE
+  field :#{columns[k].name}, types.#{type_mapper[columns[k].type]}
+            FILE
+            end
+          end
+        end
+      end
+
+      def add_methods(model)
+        associations = model.reflect_on_all_associations(:belongs_to)
+
+        associations.map(&:name).each do |ast|
+          association_klass = model.reflect_on_association(ast).class_name
+
+          begin
+            if models.include? association_klass.classify.constantize
+              if circular_finder[model.to_s].include? association_klass || association_klass == model.to_s
+                inject_into_file type_path(model), before: "# End of fields\n" do <<-FILE
+  field :#{ast.to_s} do
+    type -> { #{model.reflect_on_association(ast).class_name}Type }
+
+    resolve -> (#{singular_route_key(model)}, args, ctx) {
+      #{singular_route_key(model)}.#{ast.to_s}
+    }
+  end
+
+                FILE
+                end
+              else
+                inject_into_file type_path(model), before: "# End of fields\n" do <<-FILE
+  field :#{ast.to_s} do
+    type -> #{model.reflect_on_association(ast).class_name}Type
+
+    resolve -> (#{singular_route_key(model)}, args, ctx) {
+      #{singular_route_key(model)}.#{ast.to_s}
+    }
+  end
+                FILE
+                end
+              end
+            end
+          rescue => ex
+            puts ex
+          end
+        end
+      end
+
+      def add_connections(model)
+        associations = model.reflect_on_all_associations(:has_many)
+        associations += model.reflect_on_all_associations(:has_and_belongs_to_many)
+
+        associations.map(&:name).each do |ast|
+          association_klass = model.reflect_on_association(ast).class_name
+          begin
+            if models.include? association_klass.classify.constantize
+              if circular_finder[model.to_s].include? association_klass || association_klass == model.to_s
+                inject_into_file type_path(model), before: "# End of fields\n" do <<-FILE
+  connection :#{ast.to_s}, -> { #{model.reflect_on_association(ast).class_name}Type.connection_type } do
+    resolve ->(#{singular_route_key(model)}, args, ctx) {
+      #{singular_route_key(model)}.#{ast}
+    }
+  end
+
+                FILE
+                end
+              else
+                inject_into_file type_path(model), before: "# End of fields\n" do <<-FILE
+  connection :#{ast.to_s}, #{model.reflect_on_association(ast).class_name}Type.connection_type do
+    resolve -> (#{singular_route_key(model)}, args, ctx) {
+      #{singular_route_key(model)}.#{ast}
+    }
+  end
+                FILE
+                end
+              end
+            end
+          rescue => ex
+            puts ex
+          end
+        end
+      end
+
+      def add_connection_query(model)
+        inject_into_file 'app/graphql/types/root_level_type.rb', after: "field :id, field: GraphQL::Relay::GlobalIdField.new('RootLevel')\n" do <<-FILE
+  connection :#{model.to_s.tableize}, #{model.to_s}Type.connection_type do
+    resolve ->(object, args, ctx){
+      #{model.to_s}.all
+    }
+  end
+        FILE
+        end
+      end
+
+      def create_mutation(model)
+        create_file mutation_path(model), <<-FILE
+module #{model.to_s}Mutations
+
+  Create = GraphQL::Relay::Mutation.define do
+    name 'Create#{model.to_s}'
+
+    return_field :#{instance_name(model)}, #{model.to_s}Type
+
+    resolve -> (inputs, ctx) {
+      root = RootLevel::STATIC
+      attr = inputs.keys.inject({}) do |memo, key|
+        memo[key] = inputs[key] unless key == "clientMutationId"
+        memo
+      end
+
+      #{instance_name(model)} = #{model.to_s}.create(attr)
+
+      { #{instance_name(model)}: #{instance_name(model)} }
+    }
+  end
+
+  Update = GraphQL::Relay::Mutation.define do
+    name 'Update#{model.to_s}'
+
+    input_field :id, !types.ID
+
+    return_field :#{instance_name(model)}, #{model.to_s}Type
+
+    resolve -> (inputs, ctx) {
+      #{instance_name(model)} = NodeIdentification.object_from_id((inputs[:id]), ctx)
+      attr = inputs.keys.inject({}) do |memo, key|
+        memo[key] = inputs[key] unless key == "clientMutationId" || key == 'id'
+        memo
+      end
+
+      #{instance_name(model)}.update(attr)
+      { #{instance_name(model)}: #{instance_name(model)} }
+    }
+  end
+
+  Destroy = GraphQL::Relay::Mutation.define do
+    name "Destroy#{model.to_s}"
+
+    input_field :id, !types.ID
+
+    resolve -> (inputs, ctx) {
+      #{instance_name(model)} = NodeIdentification.object_from_id((inputs[:id]), ctx)
+      #{instance_name(model)}.destroy
+      { }
+    }
+  end
+end
+        FILE
+      end
+
+      def add_fields_to_mutation(model)
+        columns = model.columns_hash
+        columns.keys.each do |k|
+          next if %w(id created_at updated_at).include? columns[k].name
+          if columns[k].type.present?
+            inject_into_file mutation_path(model), after: "name 'Update#{model.to_s}'\n" do <<-FILE
+    input_field :#{columns[k].name}, types.#{type_mapper[columns[k].type]}
+            FILE
+            end
+
+            inject_into_file mutation_path(model), after: "name 'Create#{model.to_s}'\n", :force => true do <<-FILE
+    input_field :#{columns[k].name}, !types.#{type_mapper[columns[k].type]}
+            FILE
+            end
+          end
+        end
+      end
+
+      def add_mutation_query(model)
+        inject_into_file "app/graphql/types/mutation_type.rb", after: "name 'MutationType'\n" do <<-FILE
+  field :create#{model.to_s}, field: #{model.to_s}Mutations::Create.field
+  field :update#{model.to_s}, field: #{model.to_s}Mutations::Update.field
+  field :destroy#{model.to_s}, field: #{model.to_s}Mutations::Destroy.field
+
+        FILE
+        end
+      end
+
+      def singular_route_key(model)
+        ActiveModel::Naming.singular_route_key(model)
+      end
+
+      def mutation_path(model)
+        "app/graphql/mutations/#{singular_route_key(model)}_mutations.rb"
+      end
+
+      def type_path(model)
+        "app/graphql/types/#{singular_route_key(model)}_type.rb"
+      end
+
+      def instance_name(model)
+        ActiveModel::Naming.singular_route_key(model)
+      end
+
+      def circular_finder
+        circular_finder = {}
+
+        models.each do |m|
+          associations = m.reflect_on_all_associations.map(&:name)
+          circular_finder[m.to_s] = [] unless circular_finder[m.to_s].present?
+
+          associations.each do |k|
+            association_klass = m.reflect_on_association(k).class_name
+            circular_finder[association_klass] = [] unless circular_finder[association_klass].present?
+
+            circular_finder[association_klass] << m.to_s
+          end
+        end
+
+        @circular_finder ||= circular_finder
+      end
+    end
+  end
+end

data/lib/generators/graphql/init_generator.rb

@@ -0,0 +1,39 @@
+module Graphql
+  module Generators
+    class InitGenerator < Rails::Generators::Base
+      source_root File.expand_path('../templates', __FILE__)
+
+      def add_gems
+        gem 'graphql'
+        gem 'graphql-relay'
+        gem 'graphiql-rails'
+        gem 'graphql-formatter'
+      end
+
+      def routes
+        route "post 'graphql' => 'graph_ql#execute'"
+        route "mount GraphiQL::Rails::Engine, at: '/graphiql', graphql_path: '/graphql'"
+      end
+
+      def autoload_paths
+        application do <<-'RUBY'
+  config.autoload_paths += Dir["#{config.root}/app/graphql/**/"]
+        RUBY
+        end
+      end
+
+      def copy_templates
+        copy_file 'controllers/graph_ql_controller.rb', 'app/controllers/graph_ql_controller.rb'
+        copy_file 'models/root_level.rb', 'app/models/root_level.rb'
+        copy_file 'graph/relay_schema.rb', 'app/graphql/relay_schema.rb'
+        copy_file 'graph/node_identification.rb', 'app/graphql/node_identification.rb'
+        copy_file 'graph/types/root_level_type.rb', 'app/graphql/types/root_level_type.rb'
+        copy_file 'graph/types/query_type.rb', 'app/graphql/types/query_type.rb'
+        copy_file 'graph/types/mutation_type.rb', 'app/graphql/types/mutation_type.rb'
+
+        copy_file 'config/graphiql.rb', 'config/initializers/graphiql.rb'
+      end
+    end
+  end
+end
+

data/lib/generators/graphql/templates/config/graphiql.rb

@@ -0,0 +1 @@
+GraphiQL::Rails.config.query_params = true

data/lib/generators/graphql/templates/controllers/graph_ql_controller.rb

@@ -0,0 +1,15 @@
+class GraphQlController < ApplicationController
+  skip_before_filter :verify_authenticity_token
+
+  def execute
+    puts '-' * 100, GraphQLFormatter.new(params[:query]).to_s, '-' * 100
+    if params[:variables].present?
+      variables = JSON.parse(params[:variables])
+    else
+      variables = params[:variables]
+    end
+
+    render json: GraphQL::Query.new(RelaySchema, params[:query], variables: variables, debug: true).result
+  end
+
+end

data/lib/generators/graphql/templates/graph/node_identification.rb

@@ -0,0 +1,15 @@
+NodeIdentification = GraphQL::Relay::GlobalNodeIdentification.define do
+  # Given a UUID & the query context,
+  # return the corresponding application object
+  object_from_id -> (id, ctx) do
+    type_name, id = NodeIdentification.from_global_id(id)
+    # "Post" -> Post.find(id)
+    Object.const_get(type_name).find(id)
+  end
+
+  # Given an application object,
+  # return a GraphQL ObjectType to expose that object
+  type_from_object -> (object) do
+    (object.class.name + 'Type').constantize
+  end
+end

data/lib/generators/graphql/templates/graph/relay_schema.rb

@@ -0,0 +1,33 @@
+RelaySchema = GraphQL::Schema.new(query: QueryType, mutation: MutationType)
+
+module RelaySchemaHelpers
+  SCHEMA_DIR  = Rails.root.join('app/assets/javascripts/relay/')
+  SCHEMA_PATH = File.join(SCHEMA_DIR, 'schema.json')
+
+  def explain
+    Rails.cache.fetch checksum do
+      RelaySchema.execute GraphQL::Introspection::INTROSPECTION_QUERY
+    end
+  end
+
+  def checksum
+    files   = Dir["app/graph/**/*.rb"].reject { |f| File.directory?(f) }
+    content = files.map { |f| File.read(f) }.join
+    Digest::SHA256.hexdigest(content).to_s
+  end
+
+  def generate
+    FileUtils.mkdir_p SCHEMA_DIR
+    result = JSON.pretty_generate(RelaySchema.explain)
+    unless File.exists?(SCHEMA_PATH) && File.read(SCHEMA_PATH) == result
+      File.write(SCHEMA_PATH, result)
+    end
+  end
+
+  def remove
+    FileUtils.rm SCHEMA_PATH if File.exist? SCHEMA_PATH
+  end
+
+end
+
+RelaySchema.extend RelaySchemaHelpers

data/lib/generators/graphql/templates/graph/types/mutation_type.rb

@@ -0,0 +1,3 @@
+MutationType = GraphQL::ObjectType.define do
+  name 'MutationType'
+end

data/lib/generators/graphql/templates/graph/types/query_type.rb

@@ -0,0 +1,13 @@
+# ...and a query root
+QueryType = GraphQL::ObjectType.define do
+  name "Query"
+  description "The query root of this schema"
+
+  field :node, field: NodeIdentification.field
+
+  field :root, RootLevelType do
+    resolve -> (obj, args, ctx) { RootLevel::STATIC }
+  end
+
+  # End Of Queries
+end

data/lib/generators/graphql/templates/graph/types/root_level_type.rb

@@ -0,0 +1,8 @@
+RootLevelType = GraphQL::ObjectType.define do
+  name 'RootLevel'
+  description 'Unassociated root object queries'
+
+  interfaces [NodeIdentification.interface]
+
+  field :id, field: GraphQL::Relay::GlobalIdField.new('RootLevel')
+end

data/lib/generators/graphql/templates/models/root_level.rb

@@ -0,0 +1,7 @@
+class RootLevel < Struct.new :id
+  STATIC = new(id: 'root').freeze
+
+  def self.find(_)
+    STATIC
+  end
+end

metadata

@@ -0,0 +1,71 @@
+--- !ruby/object:Gem::Specification
+name: rails-graphql-generator
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Muhammet
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2016-05-12 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.2'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.2'
+description: This generator will put the graphql files input your app folder
+email:
+- dilekmuhammet@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/generators/graphql/USAGE
+- lib/generators/graphql/create_all_generator.rb
+- lib/generators/graphql/graphql_generator.rb
+- lib/generators/graphql/graphql_helpers.rb
+- lib/generators/graphql/init_generator.rb
+- lib/generators/graphql/templates/config/graphiql.rb
+- lib/generators/graphql/templates/controllers/graph_ql_controller.rb
+- lib/generators/graphql/templates/graph/node_identification.rb
+- lib/generators/graphql/templates/graph/relay_schema.rb
+- lib/generators/graphql/templates/graph/types/mutation_type.rb
+- lib/generators/graphql/templates/graph/types/query_type.rb
+- lib/generators/graphql/templates/graph/types/root_level_type.rb
+- lib/generators/graphql/templates/models/root_level.rb
+homepage: https://github.com/movielala/rails-graphql-generator
+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.5.1
+signing_key: 
+specification_version: 4
+summary: A rails generator for GrapphQL.
+test_files: []