graphql-rails-schemaker 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: dee18b3ddc12dcfeb8a5af7efff3f9bda49765c5
+  data.tar.gz: 11d353b219a8bd9578c45e6d00de5e924964f555
+SHA512:
+  metadata.gz: 8794d320f62f775543c675587177250f0e00af3c7154cf50ff530c279d26c4c89d437c573c63d3fbd021b5776db6bf1a307c6e7e7d539d43f6dbd29305dbd0d3
+  data.tar.gz: 9bedf41247e193fd0ef9ee5f2922c2d39cbfbb5553baca88f37935dd8c5017326b99bc60a5a7953cdef70692ce528e2fce31b5ae97d3fd2b4b38baec09ac478c

data/.gitignore

@@ -0,0 +1,9 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/

data/CODE_OF_CONDUCT.md

@@ -0,0 +1,74 @@
+# Contributor Covenant Code of Conduct
+
+## Our Pledge
+
+In the interest of fostering an open and welcoming environment, we as
+contributors and maintainers pledge to making participation in our project and
+our community a harassment-free experience for everyone, regardless of age, body
+size, disability, ethnicity, gender identity and expression, level of experience,
+nationality, personal appearance, race, religion, or sexual identity and
+orientation.
+
+## Our Standards
+
+Examples of behavior that contributes to creating a positive environment
+include:
+
+* Using welcoming and inclusive language
+* Being respectful of differing viewpoints and experiences
+* Gracefully accepting constructive criticism
+* Focusing on what is best for the community
+* Showing empathy towards other community members
+
+Examples of unacceptable behavior by participants include:
+
+* The use of sexualized language or imagery and unwelcome sexual attention or
+advances
+* Trolling, insulting/derogatory comments, and personal or political attacks
+* Public or private harassment
+* Publishing others' private information, such as a physical or electronic
+  address, without explicit permission
+* Other conduct which could reasonably be considered inappropriate in a
+  professional setting
+
+## Our Responsibilities
+
+Project maintainers are responsible for clarifying the standards of acceptable
+behavior and are expected to take appropriate and fair corrective action in
+response to any instances of unacceptable behavior.
+
+Project maintainers have the right and responsibility to remove, edit, or
+reject comments, commits, code, wiki edits, issues, and other contributions
+that are not aligned to this Code of Conduct, or to ban temporarily or
+permanently any contributor for other behaviors that they deem inappropriate,
+threatening, offensive, or harmful.
+
+## Scope
+
+This Code of Conduct applies both within project spaces and in public spaces
+when an individual is representing the project or its community. Examples of
+representing a project or community include using an official project e-mail
+address, posting via an official social media account, or acting as an appointed
+representative at an online or offline event. Representation of a project may be
+further defined and clarified by project maintainers.
+
+## Enforcement
+
+Instances of abusive, harassing, or otherwise unacceptable behavior may be
+reported by contacting the project team at turner.cole@gmail.com. All
+complaints will be reviewed and investigated and will result in a response that
+is deemed necessary and appropriate to the circumstances. The project team is
+obligated to maintain confidentiality with regard to the reporter of an incident.
+Further details of specific enforcement policies may be posted separately.
+
+Project maintainers who do not follow or enforce the Code of Conduct in good
+faith may face temporary or permanent repercussions as determined by other
+members of the project's leadership.
+
+## Attribution
+
+This Code of Conduct is adapted from the [Contributor Covenant][homepage], version 1.4,
+available at [http://contributor-covenant.org/version/1/4][version]
+
+[homepage]: http://contributor-covenant.org
+[version]: http://contributor-covenant.org/version/1/4/

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in graphql-rails-schemaker.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2016 Cole Turner
+
+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,29 @@
+# graphql-rails-schemaker
+A rake task to interactive create a GraphQL Schema for Rails Models.
+
+## To generate a base schema:
+- Run "rails graphql:generate"
+- When prompted, enter "c" or "s" for camel case or snake case output respectively.
+- Follow the prompts to generate the schema.
+
+
+### Word of Caution
+This tool is designed to facilitate setup of a GraphQL Schema in Rails 5 Application. It has not been tested in any prior verison of Rails. This task will not run it if detects a previous setup @ `./app/graph/schema.rb` It will overwrite any files in `./app/graph/` if no `schema.rb` exists.
+
+GraphQL Rails Schemaker is not a one-size-fits all solution. It will create a "base" schema including object types and sub-type dependencies from all models existing in the Rails application. It has been designed to formulate a generic schema to fit a wide variety of applications with support for associations.
+
+**Do not run this in production environments.**
+
+
+# Todo
+- Generate Enum and Union Types
+- Add Input Type templates
+- Add Mutation Type templates
+- Integration with `graphql-rails-resolver` (if installed)
+
+## Needs Help
+The `object_type.rb` template is large and cumbersome. The Todo above is planned for action. If you would like to handle any of the above, please file a pull request and add your name to the credits list.
+
+
+## Credits
+Cole Turner (http://cole.codes/)

data/Rakefile

@@ -0,0 +1,2 @@
+require "bundler/gem_tasks"
+task :default => :spec

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "graphql/rails/schemaker"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/graphql-rails-schemaker.gemspec

@@ -0,0 +1,28 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'graphql/rails/schemaker/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "graphql-rails-schemaker"
+  spec.version       = Graphql::Rails::Schemaker::VERSION
+  spec.date          = Date.today.to_s
+  spec.authors       = ["Cole Turner"]
+  spec.email         = ["turner.cole@gmail.com"]
+
+  spec.summary       = ""
+  spec.homepage      = "https://github.com/colepatrickturner/graphql-rails-schemaker"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0").reject do |f|
+    f.match(%r{^(test|spec|features)/})
+  end
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_runtime_dependency "graphql", ">= 0.19.0"
+  spec.add_development_dependency "bundler", "~> 1.13"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.required_ruby_version = '>= 2.2.2'
+end

data/lib/graphql/rails/schemaker.rb

@@ -0,0 +1,12 @@
+require "graphql/rails/schemaker/version"
+require 'graphql/rails/schemaker/railtie' if defined?(Rails)
+
+module Graphql
+  module Rails
+    module Schemaker
+      def self.root
+        File.dirname __dir__
+      end
+    end
+  end
+end

data/lib/graphql/rails/schemaker/camel_case_middleware.erb

@@ -0,0 +1,36 @@
+class CamelCaseMiddleware
+  def call(parent_type, parent_object, field_definition, field_args, query_context, next_middleware)
+    next_middleware.call([parent_type, parent_object, field_definition, transform_arguments(field_args), query_context])
+  end
+
+  def transform_arguments(field_args)
+    transformed_args = {}
+    types = {}
+
+    field_args.each_value do |arg_value|
+      key = arg_value.key.to_s
+      unless key == "clientMutationId"
+        key = key.underscore
+      end
+
+      transformed_args[key] = transform_value(arg_value.value)
+      types[key] = arg_value.definition
+    end
+
+    GraphQL::Query::Arguments.new(transformed_args, argument_definitions: types)
+  end
+
+  def transform_value(value)
+    case value
+      when Array
+        value.map { |v| transform_value(v) }
+      when Hash
+        Hash[value.map { |k, v| [underscore_key(k), convert_hash_keys(v)] }]
+      when GraphQL::Query::Arguments
+        transform_arguments(value)
+      else
+        value
+      end
+  end
+
+end

data/lib/graphql/rails/schemaker/enum_type.erb

@@ -0,0 +1,12 @@
+<%=name%>Enum = GraphQL::EnumType.define do
+  name "<%=name%>"
+  description "Enumerated values for <%=name%>"
+
+<%
+  values.each do |key,value|
+-%>
+  value(<%=key.inspect%>, <%="Value of \"#{value}\"".inspect%>, value: <%=value.inspect%>)
+<%
+  end
+  -%>
+end

data/lib/graphql/rails/schemaker/mutation_type.erb

@@ -0,0 +1,6 @@
+<%=mutation_type_name%> = GraphQL::ObjectType.define do
+  name "Mutation"
+  description "The mutation root of this schema"
+
+  #field :sampleMutation, field: SampleMutation.field
+end

data/lib/graphql/rails/schemaker/object_type.erb

@@ -0,0 +1,71 @@
+ <%=model.name%>Type = GraphQL::ObjectType.define do
+  name "<%=model.name%>"
+  description "Type for <%=model.name%> object"
+
+  interfaces [::GraphQL::Relay::Node.interface]
+
+<%
+  attributes.each do |name, attribute|
+    association = nil
+
+    if attribute.key? :association
+      association = attribute[:association]
+    elsif model.respond_to? :reflect_on_all_associations
+
+    end
+
+    if model.respond_to? :primary_key and name.to_s == model.primary_key
+-%>
+  global_id_field :<%=name%>
+<%
+    elsif association.present?
+      if association.polymorphic?
+        object_model = association.active_record
+      else
+        object_model = association.klass
+      end
+
+      if association.collection?
+        list_or_connection = nil
+        while list_or_connection.nil?
+          STDOUT.puts "Should many type `\e[32m#{name}\e[0m` on \e[32m#{model.name}\e[0m be a list or connection? (\e[34ml = list \e[39m| \e[32mc = connection \e[39m| \e[93msh = help\e[39m)."
+          command = STDIN.gets.chomp.downcase
+          case command
+          when "c", "g"
+            list_or_connection = :connection
+          when "l"
+            list_or_connection = :list
+          when "h"
+            STDOUT.puts "Lists return all objects in the association. Use connections if pagination is necessary."
+          end
+        end
+
+        if list_or_connection == :connection
+-%>
+  connection :<%=association.plural_name%>, <%=object_model.is_a?(model) or object_model == model ? "-> { " : ""%><%=object_model%>Type<%=association.polymorphic? ? "Union" : ""%>.connection_type<%=object_model.is_a?(model) or object_model == model ? " }" : ""%>, "Association to many `<%=association.plural_name%>` on <%=model.name%>"
+<%
+        else
+-%>
+  field :<%=association.plural_name%>, <%=object_model.is_a?(model) or object_model == model ? "-> { " : ""%><%=object_model%>Type<%=association.polymorphic? ? "Union" : ""%>.to_list_type<%=object_model.is_a?(model) or object_model == model ? " }" : ""%>, "Association to many `<%=association.plural_name%>` on <%=model.name%>"
+<%
+        end
+      else
+-%>
+  field :<%=association.name%>, <%=object_model.is_a?(model) or object_model == model ? "-> { " : ""%><%=object_model%>Type<%=association.polymorphic? ? "Union" : ""%><%=object_model.is_a?(model) or object_model == model ? " }" : ""%>, "Association to one `<%=association.name%>` on <%=model.name%>"
+<%
+      end
+    else
+      type_str =
+        if attribute.key? :type and attribute[:type].present?
+          attribute[:type]
+        else
+          "types.String"
+        end
+
+-%>
+  field :<%=name%>, <%=type_str%>, "Property `<%=attribute[:property]%>` for <%=model.name%>"<%=attribute[:property].to_s != name.to_s ? ", property: :#{attribute[:property]}" : ""%>
+<%
+    end
+  end
+  %>
+end

data/lib/graphql/rails/schemaker/query_type.erb

@@ -0,0 +1,13 @@
+<%= query_type_name %> = GraphQL::ObjectType.define do
+  name "Query"
+  description "The query root of this schema"
+
+  field :<%=root_type_name.underscore%> do
+    type <%=root_type_name%>Type
+    resolve -> (obj, args, ctx) {
+      ctx[:<%=root_type_name.underscore%>]
+    }
+  end
+
+  field :node, ::GraphQL::Relay::Node.field
+end

data/lib/graphql/rails/schemaker/railtie.rb

@@ -0,0 +1,11 @@
+module Graphql
+  module Rails
+    module Schemaker
+      class Railtie < ::Rails::Railtie
+        rake_tasks do
+          load 'tasks/schemaker.rake'
+        end
+      end
+    end
+  end
+end

data/lib/graphql/rails/schemaker/schema.erb

@@ -0,0 +1,24 @@
+Schema = GraphQL::Schema.define do
+  query <%= query_type_name %>
+  mutation <%= mutation_type_name %>
+
+  resolve_type -> (object, ctx) {
+    Schema.types[object.class.name]
+  }
+
+  object_from_id -> (id, ctx) {
+    type_name, object_id = GraphQL::Schema::UniqueWithinType.decode(id)
+
+    unless type_name.safe_constantize.present?
+      raise ArgumentError, "Type of object (#{type_name}) does not exist."
+    end
+
+    type_name.constantize.find(object_id)
+  }
+
+  id_from_object -> (obj, type_defn, ctx) {
+    GraphQL::Schema::UniqueWithinType.encode(type_defn.name, obj.id)
+  }
+
+  <%= middleware %>
+end

data/lib/graphql/rails/schemaker/template_renderer.rb

@@ -0,0 +1,19 @@
+require 'erb'
+
+class TemplateRenderer
+  def self.empty_binding
+    binding
+  end
+
+  def self.render_string(template_content, locals = {})
+    b = empty_binding
+    locals.each { |k, v| b.local_variable_set(k, v) }
+
+    ERB.new(template_content, nil, '-').result(b)
+  end
+
+  def self.render(file, locals = {})
+    path = File.join Graphql::Rails::Schemaker.root, file
+    render_string(File.read(path), locals)
+  end
+end

data/lib/graphql/rails/schemaker/union_type.erb

@@ -0,0 +1,5 @@
+<%=polymorphic.name.to_s.camelize%>TypeUnion = GraphQL::UnionType.define do
+  name "<%=polymorphic.name.to_s.camelize%>"
+  description "Objects for `<%=polymorphic.active_record.name.to_s%>`"
+  possible_types [<%=associations.map(&:name).map { |n| "#{n.to_s.camelize}Type" }.join(", ")%>]
+end

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

@@ -0,0 +1,7 @@
+module Graphql
+  module Rails
+    module Schemaker
+      VERSION = "0.1.0"
+    end
+  end
+end

data/lib/tasks/schemaker.rake

@@ -0,0 +1,569 @@
+require 'fileutils'
+require 'set'
+require 'graphql/rails/schemaker/template_renderer'
+
+namespace :schemaker do
+  desc "Tasks for operating a GraphQL Schema Server"
+
+  task introspect: :environment do
+    viewer = SystemViewer.new
+
+    query_string = GraphQL::Introspection::INTROSPECTION_QUERY
+    result_hash = Schema.execute(query_string, context: {viewer: viewer})
+
+    File.open("./build/schema.json","w+") do |f|
+      f.write(result_hash.to_json)
+    end
+  end
+
+  task generate: :environment do
+    if File.exist? "./app/graph/schema.rb"
+      abort "\e[1mAnother schema already exists @ ./app/graph/schema.rb\e[0m"
+    end
+
+    # Ensure directories are available
+    #FileUtils::mkdir_p Rails.root.join("app", "graph", "mutations")
+    #FileUtils::mkdir_p Rails.root.join("app", "graph", "resolvers")
+    FileUtils::mkdir_p Rails.root.join("app", "graph", "types")
+
+    # Load our application
+    Rails.application.eager_load!
+    models = ApplicationRecord.descendants.collect { |type| type }
+    scalar_types = [:string, :integer, :float, :id, :boolean]
+
+    # Determine whether to do snake case or camel case
+    STDOUT.puts "\e[1mUse camelCase or snake_case? Enter (c/S).\e[0m"
+    name_format =
+      if STDIN.gets.chomp.downcase == 'c'
+        :camel
+      else
+        :snake
+      end
+
+    # Function to convert object types to string
+    object_type_to_string = lambda { |model, attributes|
+      TemplateRenderer.render("rails/schemaker/object_type.erb", { model: model, attributes: attributes, all_models: models })
+    }
+
+    # Function to convert enum types to string
+    enum_type_to_string = lambda { |name, values|
+      TemplateRenderer.render("rails/schemaker/enum_type.erb", { name: name, values: values })
+    }
+
+    # Function to write object types
+    put_object_type = lambda { |file, model, attributes|
+      File.open(file, 'w+') { |file| file.write(object_type_to_string.call(model, attributes)) }
+    }
+
+    # Function to write enum types
+    put_enum_type = lambda { |file, name, value|
+      File.open(file, 'w+') { |file| file.write(enum_type_to_string.call(name, value)) }
+    }
+
+    STDOUT.puts "Using #{name_format == :camel ? 'camel case' : 'snake case'}"
+
+    # Schema vars
+    query_type_name = "QueryType"
+    while ApplicationRecord.descendants.map(&:name).include? query_type_name
+      if query_type_name == "QueryType"
+        query_type_name = "QueryRootType"
+      elsif query_type_name == "QueryRootType"
+        query_type_name = "QueryRootObjectType"
+      elsif query_type_name == "QueryRootObjectType"
+        STDOUT.puts "Unable to formulate a query root type name - taken: QueryType, QueryRootType, QueryRootObjectType"
+        abort "Exiting..."
+      end
+    end
+
+    mutation_type_name = "MutationType"
+    while ApplicationRecord.descendants.map(&:name).include? mutation_type_name
+      if query_type_name == "MutationType"
+        query_type_name = "MutationRootType"
+      elsif query_type_name == "MutationRootType"
+        query_type_name = "MutationRootObjectType"
+      elsif query_type_name == "MutationRootObjectType"
+        STDOUT.puts "Unable to formulate a mutation root type name - taken: MutationType, MutationRootType, MutationRootObjectType"
+        abort "Exiting..."
+      end
+    end
+
+    # The Main Schema entry point
+    schema_rb_file = "./app/graph/schema.rb"
+    unless File.exist? schema_rb_file
+      STDOUT.puts "\e[1m\e[32mGenerating Schema Root...\e[0m"
+
+      middleware = name_format == :camel ? "middleware AuthorizationMiddleware.new" : ""
+
+      src = TemplateRenderer.render("rails/schemaker/schema.erb", { middleware: middleware, query_type_name: query_type_name, mutation_type_name: mutation_type_name })
+
+      File.open(schema_rb_file, 'w+') { |file| file.write(src) }
+    end
+
+    # Camel Case Middleware
+    if name_format == :camel
+      FileUtils::mkdir_p Rails.root.join("app", "graph", "middleware")
+
+      middleware_rb_file = "./app/graph/middleware/camel_case_middleware.rb"
+      unless File.exist? middleware_rb_file
+        src = TemplateRenderer.render("rails/schemaker/camel_case_middleware.erb")
+
+        File.open(middleware_rb_file, 'w+') { |file| file.write(src) }
+      end
+    end
+
+    fake_association = Class.new(Object) {
+      def initialize(model, plural_name:, macro: :has_many, polymorphic: false)
+          @model = model
+          @plural_name = plural_name || model.name.pluralize
+          @macro = macro
+          @polymorphic = polymorphic
+      end
+
+      def klass() @model end
+      def macro() @macro end
+      def plural_name() @plural_name end
+      def polymorphic?() @polymorphic end
+      def collection?() [:has_many, :has_and_belongs_to_many].include?(@macro) end
+    }
+
+    scalar_types = { :id => "types.ID", :boolean => "types.Boolean", :integer => "types.Int", :float => "types.Float", :decimal => "types.Float", :string => "types.String"}
+
+    guess_type = lambda { |model, name|
+      return :enum if model.defined_enums.key?(name)
+      matches = model.columns.select { |c| c.name == name }
+
+      return matches.first.type if matches.present?
+
+      :string
+    }
+
+    graphl_field_type = Proc.new { |type, name|
+      graphql_type = nil
+      graphql_type = scalar_types[type.to_sym] if scalar_types.key? type.to_sym
+
+      if type == :enum
+        graphql_type = "#{name.to_s.camelize}Enum"
+      end
+
+      graphql_type = scalar_types[:string] if type.nil?
+
+      graphql_type
+    }
+
+    STDOUT.puts ""
+    STDOUT.puts "\e[1m\e[32mGenerating Object Types...\e[0m"
+
+    active_models = []
+    active_enum = {}
+    active_models_attributes = {}
+    models.each do |model|
+      model.connection
+      skipped = false
+      STDOUT.puts
+      STDOUT.puts "----------------------------------"
+      STDOUT.puts "\e[1mGenerating type for model: \e[32m#{model}\e[0m"
+      attributes = Set.new
+      attribute_types = {}
+      attribute_graphql_types = {}
+      attribute_properties = {}
+      attribute_associations = {}
+
+      # Track all the columns
+      model.columns.each do |column|
+        name = column.name
+
+        type_sym =
+          if model.defined_enums.key? name
+            :enum
+          else
+            column.type
+          end
+
+        graphql_type = graphl_field_type.call(type_sym, name)
+
+        new_name = name_format == :camel ? name.camelize(:lower).to_sym : name.underscore.to_sym
+        attributes.add(new_name)
+        attribute_types[new_name] = type_sym
+        attribute_graphql_types[new_name] = graphql_type
+        attribute_properties[new_name] = name
+      end
+
+      # Track all associations
+      model.reflect_on_all_associations.each do |association|
+        name = association.collection? ? association.plural_name.to_s : association.name.to_s
+        type = :object
+
+        new_name = name_format == :camel ? name.camelize(:lower).to_sym : name.underscore.to_sym
+        attributes.add(new_name)
+        attribute_types[new_name] = type
+        attribute_graphql_types[new_name] = graphl_field_type.call(type, name)
+        attribute_properties[new_name] = name
+        attribute_associations[new_name] = association
+      end
+
+      # Process commands for each model
+      last_input = $_
+      is_repeating = false
+      while last_input != "g"
+        unless is_repeating
+          STDOUT.puts
+          STDOUT.puts "Using attributes: #{attributes.to_a.join(", ")}"
+          STDOUT.puts "To continue, enter one of the following commands: (\e[34mg = generate \e[39m| \e[31mr = remove attribute \e[39m| \e[32ma = add attribute \e[39m| \e[93ms = skip model\e[39m)"
+          command = STDIN.gets.chomp.downcase
+        end
+
+        is_repeating = false
+
+        case command
+        when "s"
+          skipped = true
+          break
+        when "a"
+          STDOUT.puts
+          STDOUT.puts "Enter attribute name and type in following format: \e[32m#{name_format == :snake ? "property_name" : "columName"}\e[39m:(\e[96m#{scalar_types.join("\e[39m|\e[96m")}\e[39m)"
+          raw_attr = STDIN.gets.chomp.downcase
+          new_attr = raw_attr
+
+          if name_format == :camel
+            new_attr = raw_attr.camelize(:lower)
+          else
+            new_attr = raw_attr.underscore
+          end
+
+          unless new_attr === raw_attr
+            STDOUT.puts "Converting to #{name_format == :camel ? 'camelCase' : 'snake_case'} - \"#{new_attr}\""
+          end
+
+          unless new_attr.present?
+            is_repeating = false
+            next
+          end
+
+          unless new_attr.include? ":"
+            last_input = "a"
+            is_repeating = true
+            next
+          end
+
+          name, type = new_attr.split(":")
+          property = name
+          tries = 0;
+
+          if attributes.include? name.to_sym
+            STDOUT.puts "Attribute #{name} already exists. Retrying..."
+            is_repeating = false
+            next
+          end
+
+          until model.column_names.include? property or model.respond_to? property.to_sym
+            if tries >= 3
+              STDOUT.puts "Tried three times. Retrying..."
+              break
+            end
+
+            STDOUT.puts "#{model} does not possess property \"#{property}\", what should \"#{name}\" respond with?"
+            input = STDIN.gets.chomp
+            property = input if input.present?
+
+            tries += 1
+          end
+
+          if property.nil?
+            is_repeating = true
+            next
+          end
+
+          unless name == property
+            attribute_properties[name] = property
+          end
+
+          attributes.add(name.to_sym)
+          attribute_types[name.to_sym] = type
+          attribute_graphql_types[name.to_sym] = graphl_field_type.call(type, name.to_sym)
+
+        when "r"
+          STDOUT.puts "Enter the name of the attribute to remove:"
+          raw_attr = STDIN.gets.chomp.downcase
+
+          if raw_attr.include? ":"
+            raw_attr = raw_attr.split(":").first
+          end
+
+          remove_attr = raw_attr
+
+          if name_format == :camel
+            remove_attr = raw_attr.camelize(:lower)
+          else
+            remove_attr = raw_attr.underscore
+          end
+
+          unless remove_attr === raw_attr
+            STDOUT.puts "Converting to #{name_format == :camel ? 'camelCase' : 'snake_case'} - \"#{remove_attr}\""
+          end
+
+          unless attributes.include? remove_attr.to_sym
+            STDOUT.puts "Attribute \"#{remove_attr}\" does not exist."
+            is_repeating = true
+            next
+          end
+
+          STDOUT.puts "Removing attribute \"#{remove_attr}\"."
+          attributes.delete(remove_attr.to_sym)
+          attribute_types.delete remove_attr.to_sym
+          attribute_graphql_types.delete remove_attr.to_sym
+          attribute_properties.delete remove_attr.to_sym
+
+          is_repeating = false
+        when "g"
+          break
+        else
+          STDOUT.puts "Unrecognized command #{command}"
+        end
+
+      end
+
+      if skipped
+        STDOUT.puts "\e[93mSkipping #{model.name}...\e[39m"
+        next
+      end
+
+      object_type_file = "./app/graph/types/#{model.name.underscore}_type.rb"
+      attr_composed = {}
+
+      attributes.each do |attribute|
+        hash = { :type => attribute_types[attribute], :graphql_type => attribute_graphql_types[attribute], :property => attribute_properties[attribute] }
+
+        if attribute_associations.key? attribute
+          hash[:association] = attribute_associations[attribute]
+        end
+
+        if model.defined_enums.key? hash[:property]
+          active_enum[attribute.to_s.camelize] = model.defined_enums[hash[:property]]
+        end
+
+        attr_composed[attribute] = hash
+      end
+
+      put_object_type.call(object_type_file, model, attr_composed.sort_by { |k,v| [k == :id ? 0 : 1, k] })
+
+      # Save this config for later
+      active_models.push(model)
+      active_models_attributes[model] = attr_composed
+
+      # Todo
+      # 2. Generate input types
+      # 4. Generate generic resolvers (if using graphql-rails-resolver)
+
+    end
+
+    puts "active_enum = #{active_enum}"
+    if active_enum.present?
+      STDOUT.puts ""
+      STDOUT.puts "----------------------------------"
+      STDOUT.puts ""
+      STDOUT.puts "\e[1m\e[32mGenerating Enum Types...\e[0m"
+
+      active_enum.each do |name, values|
+      enum_type_file = "./app/graph/types/#{name.underscore}_enum.rb"
+
+        STDOUT.puts "\e[34m#{name}Enum\e[0m"
+        put_enum_type.call(enum_type_file, name, values)
+      end
+  end
+
+    STDOUT.puts ""
+    STDOUT.puts "----------------------------------"
+    STDOUT.puts ""
+
+    # Generate union types from generated models
+    polymorphics = active_models.map { |m| m.reflect_on_all_associations.select(&:polymorphic?) }.flatten
+    if polymorphics.present?
+      STDOUT.puts "\e[1m\e[32mGenerating Union Types...\e[0m"
+      polymorphics.each do |polymorphic|
+
+        STDOUT.puts "\e[34m#{polymorphic.name.to_s.camelize}Type\e[0m"
+
+        polymorphic_rb_file = "./app/graph/types/#{polymorphic.name}_union.rb"
+        associations = active_models.select { |m| m.reflect_on_all_associations.select{ |j| j.options[:as] == polymorphic.name }.present? }
+
+          src = TemplateRenderer.render("rails/schemaker/union_type.erb", { polymorphic: polymorphic, associations: associations })
+
+          File.open(polymorphic_rb_file, 'w+') { |file| file.write(src) }
+      end
+    end
+
+    STDOUT.puts ""
+    STDOUT.puts "----------------------------------"
+    STDOUT.puts ""
+
+    STDOUT.puts "\e[1m\e[32mGenerating Query Root...\e[0m"
+    STDOUT.puts "A query root is the entry point to your Schema."
+    STDOUT.puts ""
+    STDOUT.puts "If you plan to use Relay v1, your Schema needs a global node to work properly."
+    STDOUT.puts "See https://github.com/facebook/relay/issues/112 for more info."
+
+    STDOUT.puts ""
+    STDOUT.puts "----------------------------------"
+    STDOUT.puts ""
+
+    STDOUT.puts "How would you like to generate your query root?"
+    STDOUT.puts "1 - Use Global Node (default)"
+    STDOUT.puts "2 - Expose all fields on query root"
+    STDOUT.puts ""
+
+    command = STDIN.gets.chomp.downcase
+    until ["1", "2", "", "g"].include? command
+      STDOUT.puts "\"#{command}\" not recognized."
+      command = STDIN.gets.chomp.downcase
+    end
+
+    if ["", "g"].include? command
+      command = "1"
+    end
+
+    # Generate global node for query root
+    if command == "1"
+      root_type_name = nil
+
+      # Check if developers already made a global node model
+      if active_models.map(&:name).include? "Viewer"
+        STDOUT.puts "A model by the name 'Viewer' already exists. Should this model be the global node? (Y/n)"
+
+        command = STDIN.gets.chomp.downcase
+        until ["y", "n", "", "g"].include?(command)
+          STDOUT.puts "\"#{command}\" not recognized."
+          command = STDIN.gets.chomp.downcase
+        end
+
+        if ["", "g"].include? command
+          command = "y"
+        end
+
+        root_type_name = "Viewer"
+
+        # Reconfigure the file
+        model = active_models.select { |m| m.name == "Viewer" }.first
+        attributes = active_models_attributes[model]
+
+        root_type_attr = {}
+
+        active_models.map do |model|
+          key = model.name.pluralize
+
+          if name_format == :camel
+            key = key.camelize(:lower)
+          else
+            key = key.underscore
+          end
+
+          while key.nil? or attributes.key? key or attributes.key? key.to_sym
+            STDOUT.puts "Field `\e[31m#{key}\e[0m` already exists on `\e[32m#{root_type_name}\e[0m`. Enter a new name for the field:"
+            command = STDIN.gets.chomp
+            unless command.present? and command[/[a-zA-Z]+/] == command
+              command = nil
+              next
+            end
+
+            key = command
+          end
+
+          if name_format == :camel
+            key = key.camelize(:lower)
+          else
+            key = key.underscore
+          end
+
+          association = fake_association.new(model, plural_name: key)
+          association.polymorphic?
+
+          root_type_attr[key] = { :type => :id, :association => association}
+        end
+
+        object_type_file = "./app/graph/types/#{model.name.underscore}_type.rb"
+        sorted_fields = Hash[root_type_attr.sort_by{ |k,v| k }]
+        put_object_type.call(object_type_file, model, attributes.merge(sorted_fields))
+      else
+        STDOUT.puts "Define the root type to expose your object types: (letters only) (default = \e[32mViewer\e[0m)"
+        name_command = STDIN.gets.chomp.downcase
+        while root_type_name.nil?
+          if name_command.empty?
+            root_type_name = "Viewer"
+          else
+            unless name_command[/[a-zA-Z]+/] == name_command
+              STDOUT.puts "Root type name must contain only letters. No numbers or special characters."
+              next
+            end
+
+            if models.map(&:name).include?(name_command)
+              STDOUT.puts "A model already exists by that name. Are you sure? (y/N)"
+              command = STDIN.gets.chomp.downcase
+              until ["y", "n", ""].include?(command)
+                STDOUT.puts "\"#{command}\" not recognized."
+                command = STDIN.gets.chomp.downcase
+              end
+
+              if command == ""
+                command = "n"
+              end
+
+              if command == "n"
+                next
+              end
+            end
+
+            root_type_name = name_command.classify
+          end
+        end
+
+        # Generate global node type with generated models
+        Object.const_set(root_type_name, Class.new { def name() root_type_name end  })
+
+        root_type_attr = {}
+        active_models.each do |model|
+          key = model.name.pluralize
+
+          if name_format == :camel
+            key = key.camelize(:lower)
+          else
+            key = key.underscore
+          end
+
+          association = fake_association.new(model, plural_name: key)
+          root_type_attr[key] = { :type => :id, :association => association}
+        end
+
+        root_object_type_file = "./app/graph/types/#{root_type_name.underscore}_type.rb"
+        put_object_type.call(root_object_type_file, root_type_name.constantize, root_type_attr)
+
+      end
+    end
+
+    # Generate the Query root type (include)
+    query_type_rb_file = "./app/graph/types/#{query_type_name.underscore}.rb"
+    unless File.exist? query_type_rb_file
+      STDOUT.puts "Generating Query Root Type..."
+
+      src = TemplateRenderer.render("rails/schemaker/query_type.erb", { query_type_name: query_type_name, root_type_name: root_type_name })
+
+      File.open(query_type_rb_file, 'w+') { |file| file.write(src) }
+    end
+
+
+    # Generate the Mutation root type (include)
+    # TODO - Add Mutations
+    mutation_type_rb_file = "./app/graph/types/#{mutation_type_name.underscore}.rb"
+    unless File.exist? mutation_type_rb_file
+      STDOUT.puts "Generating Mutation Root Type..."
+
+      src = TemplateRenderer.render("rails/schemaker/mutation_type.erb", { mutation_type_name: mutation_type_name })
+
+      File.open(mutation_type_rb_file, 'w+') { |file| file.write(src) }
+    end
+
+
+    STDOUT.puts "\e[32mDone...\e[0m"
+
+
+  end
+
+end

metadata

@@ -0,0 +1,109 @@
+--- !ruby/object:Gem::Specification
+name: graphql-rails-schemaker
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Cole Turner
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2016-10-31 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: graphql
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.19.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.19.0
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.13'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.13'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+description: 
+email:
+- turner.cole@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- CODE_OF_CONDUCT.md
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- graphql-rails-schemaker.gemspec
+- lib/.DS_Store
+- lib/graphql/rails/.DS_Store
+- lib/graphql/rails/schemaker.rb
+- lib/graphql/rails/schemaker/camel_case_middleware.erb
+- lib/graphql/rails/schemaker/enum_type.erb
+- lib/graphql/rails/schemaker/mutation_type.erb
+- lib/graphql/rails/schemaker/object_type.erb
+- lib/graphql/rails/schemaker/query_type.erb
+- lib/graphql/rails/schemaker/railtie.rb
+- lib/graphql/rails/schemaker/schema.erb
+- lib/graphql/rails/schemaker/template_renderer.rb
+- lib/graphql/rails/schemaker/union_type.erb
+- lib/graphql/rails/schemaker/version.rb
+- lib/tasks/schemaker.rake
+homepage: https://github.com/colepatrickturner/graphql-rails-schemaker
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.2.2
+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: ''
+test_files: []