graphql_scaffold 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: ff7d05ae97ea0004f7c28ce3e5b14b697348fc750e14b97009ea8186bde9f5d9
+  data.tar.gz: 135d80c2385192dff79b61d9ae53491160392ca8abc1b79bdc9c4eede3963cea
+SHA512:
+  metadata.gz: c2349f064107e60f664edc85501e55a91a36ad998e15973d9790d5d994d0ad0036cab218eb73dde7437ba2782a2bb4386631226bc587aef3e8e15adde5827ea3
+  data.tar.gz: 9b43c9c482d02f8abc4f21bdb80b62ee59bff69efb80944aa6b59386c78939d6a9548176a734f37b5248703ef1ff475c70982bb5cdffa05ae6b1e2ee3ef29522

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2019 Arthur Molina
+
+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/lib/generators/graphql_scaffold_common_methods.rb

@@ -0,0 +1,140 @@
+# frozen_string_literal: true
+
+module GraphqlScaffoldCommonMethods
+  private
+
+  def model_exists?
+    ActiveRecord::Base.connection.tables.include?(plural_name)
+  end
+
+  def singular_name
+    name.underscore.singularize
+  end
+
+  def singular_name_snaked
+    singular_name.gsub(' ', '_')
+  end
+
+  def singular_name_camelized
+    singular_name_snaked.camelcase
+  end
+
+  def plural_name
+    name.underscore.pluralize
+  end
+
+  def plural_name_snaked
+    plural_name.gsub(' ', '_')
+  end
+
+  def plural_name_camelized
+    plural_name_snaked.camelcase
+  end
+
+  def list_many
+    "all_#{plural_name_snaked}"
+  end
+
+  def list_one
+    singular_name_snaked
+  end
+
+  def create_one
+    "create_#{singular_name_snaked}"
+  end
+
+  def change_one
+    "change_#{singular_name_snaked}"
+  end
+
+  def destroy_one
+    "destroy_#{singular_name_snaked}"
+  end
+
+  def model_name
+    name.gsub('_', ' ').titlecase.gsub(' ', '')
+  end
+
+  def model
+    (eval model_name)
+  end
+
+  def primary_key
+    if model_exists?
+      model.primary_key
+    else
+      'id'
+    end
+  end
+
+  def columns_type_without_primary_key
+    columns_types.select{|c| !c[:name].in?([primary_key, 'created_at', 'updated_at']) }
+  end
+
+  def columns_types
+    if model_exists?
+      if myattributes.present?
+        columns_model.select{ |elem|
+          columns_myattributes.select{ |el| elem[:name] == el[:name]}.present?
+        } 
+      else
+        columns_model
+      end
+    else
+      columns_myattributes
+    end
+  end
+
+  def columns_model
+    model.columns_hash.map{|k,v| {name: k, type: type(v.type), null: v.null, sample: sample(v.type)}}
+  end
+
+  def columns_myattributes
+    res = [{name: 'id', type: type(:integer), null: false}]
+    res = res + myattributes.map{|element|
+      div = element.split(':')
+      type_defined = div[1].present? ? div[1].split('{')[0] : :string
+      {name: div[0], type: type(type_defined), null: false, sample: sample(type_defined)}
+    } 
+    res << {name: 'created_at', type: type(:datetime), null: false, sample: sample(:datetime)}
+    res << {name: 'updated_at', type: type(:datetime), null: false, sample: sample(:datetime)}
+  end
+
+  def type(the_type)
+    case the_type
+    when :datetime
+      'Types::DateTimeType'
+    when 'references'
+      'Integer'
+    else
+      the_type.to_s.titlecase
+    end
+  end
+
+  def sample(the_type)
+    case the_type.to_s.downcase
+    when 'datetime'
+      Time.now.strftime("%d/%m/%Y %H:%M:%S")
+    when 'references', 'integer', 'float'
+      rand(1..10).to_s
+    else
+      the_type.to_s.titlecase
+    end
+  end
+
+  def require_gems
+    gems = {
+      'graphql' => '1.9.15',
+      'search_object' => '1.2.0',
+      'search_object_graphql' => '0.1'
+    }
+
+    if !Dir.glob('./*.gemspec').empty?
+      puts "============> Engine : You must add gems to your main app \n #{gems.to_a.map{ |a| "gem '#{a[0]}'#{(a[1].nil? ? '' : ", '#{a[1]}'")} " }.join("\n")}"
+    end
+
+    gems.each{ |gem_to_add, version|
+      gem(gem_to_add, version)
+    }
+  end
+end

data/lib/generators/graphql_scaffold_generator.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+class GraphqlScaffoldGenerator < Rails::Generators::Base
+  require_relative 'graphql_scaffold_common_methods'
+  include GraphqlScaffoldCommonMethods
+
+  desc 'This generator scaffolds a Graphql from a table.'
+
+  source_root File.expand_path('../templates', __FILE__)
+
+  argument :name, type: :string, desc: 'Name of model (singular)'
+  argument :myattributes, type: :array, default: [], banner: 'field:type field:type'
+
+  class_option :namespace, default: nil
+  class_option :donttouchgem, default: nil
+  class_option :mountable_engine, default: true
+
+  def check_model_existence
+    unless model_exists?
+      if myattributes.present?
+        puts 'Generating model...'
+        generate('model', "#{name} #{myattributes.join(' ')}")
+      else
+        puts "The model #{name} wasn't found. You can add attributes and generate the model with Graphql Scaffold."
+        exit
+      end
+    end
+  end
+
+  def install_gems
+    return true
+    require_gems if options[:donttouchgem].blank?
+
+    Bundler.with_clean_env do
+      run 'bundle install'
+    end
+
+    if options[:donttouchgem].blank?
+      generate('graphql:install')
+      run 'bundle install'
+    end
+  end
+
+  def copy_files
+    copy_file 'app/graphql/resolvers/base_search_resolver.rb', 'app/graphql/resolvers/base_search_resolver.rb'
+    copy_file 'app/graphql/types/enums/operator.rb', 'app/graphql/types/enums/operator.rb'
+    copy_file 'app/graphql/types/enums/sort_dir.rb', 'app/graphql/types/enums/sort_dir.rb'
+    copy_file 'app/graphql/types/date_time_type.rb', 'app/graphql/types/date_time_type.rb'
+    copy_file 'app/graphql/types/base_field.rb', 'app/graphql/types/base_field.rb'
+    copy_file 'app/graphql/mutations/base_mutation.rb', 'app/graphql/mutations/base_mutation.rb'
+    copy_file 'test/integration/graphql_1st_test.rb', 'test/integration/graphql_1st_test.rb'
+  end
+
+  def generate_graphql_query
+    template 'app/graphql/types/enums/table_field.rb', "app/graphql/types/enums/#{plural_name_snaked}_field.rb"
+    template 'app/graphql/types/table_type.rb', "app/graphql/types/#{singular_name_snaked}_type.rb"
+    template 'app/graphql/resolvers/table_search.rb', "app/graphql/resolvers/#{plural_name_snaked}_search.rb"
+    template 'app/graphql/mutations/change_table.rb', "app/graphql/mutations/change_#{singular_name_snaked}.rb"
+    template 'app/graphql/mutations/create_table.rb', "app/graphql/mutations/create_#{singular_name_snaked}.rb"
+    template 'app/graphql/mutations/destroy_table.rb', "app/graphql/mutations/destroy_#{singular_name_snaked}.rb"
+    template 'test/integration/graphql_table_test.rb', "test/integration/graphql_#{singular_name_snaked}_test.rb"
+  end
+
+  def add_in_query_type
+    inject_into_file(
+      'app/graphql/types/query_type.rb', 
+      "    field :#{list_many}, function: Resolvers::#{plural_name_camelized}Search\n", 
+      after: "class QueryType < Types::BaseObject\n")
+
+    inject_into_file(
+      'app/graphql/types/mutation_type.rb', 
+      "\n    field :#{create_one}, mutation: Mutations::Create#{singular_name_camelized}" +
+      "\n    field :#{change_one}, mutation: Mutations::Change#{singular_name_camelized}" +
+      "\n    field :#{destroy_one}, mutation: Mutations::Destroy#{singular_name_camelized}\n",
+      after: "class MutationType < Types::BaseObject\n")
+  end
+
+end

data/lib/generators/templates/app/graphql/mutations/base_mutation.rb

@@ -0,0 +1,11 @@
+class Mutations::BaseMutation < GraphQL::Schema::RelayClassicMutation
+  # Add your custom classes if you have them:
+  # This is used for generating payload types
+  object_class Types::BaseObject
+  
+  # This is used for return fields on the mutation's payload
+  field_class Types::BaseField
+
+  # This is used for generating the `input: { ... }` object type
+  input_object_class Types::BaseInputObject
+end

data/lib/generators/templates/app/graphql/mutations/change_table.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+class Mutations::Change<%= singular_name_camelized %> < Mutations::BaseMutation
+  description 'Change a <%= singular_name_camelized %> record'
+  #graphql_name 'Change<%= singular_name_camelized %>'
+
+<% for attribute in columns_types -%>
+  argument :<%= attribute[:name] %>, <%= attribute[:name] == primary_key ? 'ID' : attribute[:type] %>, required: <%= attribute[:name] == primary_key ? 'true' : 'false' %>
+<% end -%>
+
+  field :<%= singular_name_snaked %>, Types::<%= singular_name_camelized %>Type, null: true
+  field :errors, [String], null: false
+
+  def resolve(**args)
+    <%= singular_name_snaked %> = <%= singular_name_camelized %>.find(args[:id])
+    <%= singular_name_snaked %>.update(args)
+    return {
+      <%= singular_name_snaked %>: <%= singular_name_snaked %>,
+      errors: <%= singular_name_snaked %>.errors.full_messages
+    }
+  rescue ActiveRecord::RecordInvalid => e
+    GraphQL::ExecutionError.new("Invalid input: #{e.record.errors.full_messages.join(', ')}")
+  end
+end

data/lib/generators/templates/app/graphql/mutations/create_table.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+class Mutations::Create<%= singular_name_camelized %> < Mutations::BaseMutation
+  null true
+  description 'Create a <%= singular_name_camelized %> record'
+  #graphql_name 'Create<%= singular_name_camelized %>'
+
+<% for attribute in columns_types
+  next if attribute[:name] == primary_key
+ -%>
+  argument :<%= attribute[:name] %>, <%= attribute[:type] %>, required: false
+<% end -%>
+
+  field :<%= singular_name_snaked %>, Types::<%= singular_name_camelized %>Type, null: true
+  field :errors, [String], null: false
+
+  def resolve(**args)
+    <%= singular_name_snaked %> = <%= singular_name_camelized %>.new(args)
+    if <%= singular_name_snaked %>.save
+      return {
+        <%= singular_name_snaked %>: <%= singular_name_snaked %>,
+        errors: []
+      }
+    else
+      return {
+        <%= singular_name_snaked %>: nil,
+        errors: <%= singular_name_snaked %>.errors.full_messages
+      }
+    end
+  rescue ActiveRecord::RecordInvalid => e
+    GraphQL::ExecutionError.new("Invalid input: #{e.record.errors.full_messages.join(', ')}")
+  end
+end

data/lib/generators/templates/app/graphql/mutations/destroy_table.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+class Mutations::Destroy<%= singular_name_camelized %> < Mutations::BaseMutation
+  description 'Destroy a <%= singular_name_camelized %> record'
+  #graphql_name 'Destroy<%= singular_name_camelized %>'
+
+  argument :<%= primary_key %>, ID, required: true
+
+  field :<%= singular_name_snaked %>, Types::<%= singular_name_camelized %>Type, null: true
+  field :errors, [String], null: false
+
+  def resolve(**args)
+    <%= singular_name_snaked %> = <%= singular_name_camelized %>.find(args[:<%= primary_key %>])
+    <%= singular_name_snaked %>.destroy
+    return {
+      <%= singular_name_snaked %>: <%= singular_name_snaked %>,
+      errors: <%= singular_name_snaked %>.errors.full_messages
+    }
+  rescue ActiveRecord::RecordInvalid => e
+    GraphQL::ExecutionError.new("Invalid input: #{e.record.errors.full_messages.join(', ')}")
+  end
+end

data/lib/generators/templates/app/graphql/resolvers/base_search_resolver.rb

@@ -0,0 +1,119 @@
+# frozen_string_literal: true
+
+module Resolvers
+  class BaseSearchResolver
+    include SearchObject.module(:graphql)
+  	include SearchObject.module(:enum)
+
+    def escape_search_term(term)
+      "%#{term.gsub(/\s+/, '%')}%"
+    end
+
+    def query_where(value)
+      redefine_values(transform_element(arguments_to_h(value)))
+    end
+
+    def arguments_to_h(value)
+      if value.is_a? Array
+        value.map{ |v| arguments_to_h(v) }
+      else
+        value.to_h
+      end
+    end
+
+    def has_comparison?(values)
+      values[:field].present? and values[:operator].present? and values[:value].present?
+    end
+
+    def transform_element(v, and_or_check = true)
+      and_or = and_or_check ? ' and ' : ' or '
+      values = v.clone
+      return '' if values.nil?
+      if values.is_a? Array
+        return "(#{values.map{ |v| transform_element(v) }.join(and_or)})"
+      elsif values.is_a? Hash
+        if values[:_or].present?
+          values[:_or].push({field: values[:field], operator: values[:operator], value: values[:value]}) if has_comparison?(values)
+          return transform_element(values[:_or], false) 
+        elsif values[:_and].present?
+          values[:_and].push({field: values[:field], operator: values[:operator], value: values[:value]}) if has_comparison?(values)
+          return transform_element(values[:_and], true)
+        elsif values[:_not].present?
+          addon = has_comparison?(values) ? convert_element(values) + and_or : ''
+          res = transform_element(values[:_not], and_or_check)
+          return "#{addon}not (#{res.is_a?(String) ? res : res.join(and_or)})"
+        else
+          return convert_element values
+        end
+      else
+        return values
+      end
+    end
+
+    def convert_element(values)
+      return '' if not has_comparison?(values)
+
+      values[:field] + case values[:operator]
+      when 'equal', 'in'
+        " in (<var!>#{values[:value].to_json}</var!>)"
+      when 'greater_than'
+        " > <var!>#{values[:value].to_json}</var!>"
+      when 'greater_than_or_equal_to'
+        " >= <var!>#{values[:value].to_json}</var!>"
+      when 'ilike'
+        " ilike <var!>#{values[:value].to_json}</var!>"
+      when 'is_null'
+        " is #{values[:value].downcase == 'true' ? '' : 'not'} null"
+      when 'like'
+        " like <var!>#{values[:value].to_json}</var!>"
+      when 'less_than'
+        " < <var!>#{values[:value].to_json}</var!>"
+      when 'less_than_or_equal_to'
+        " <= <var!>#{values[:value].to_json}</var!>"
+      when 'not_equal', 'not_in'
+        " not in (<var!>#{values[:value].to_json}</var!>)"
+      when 'not_ilike'
+        " not ilike <var!>#{values[:value].to_json}</var!>"
+      when 'not_like'
+        " not like <var!>#{values[:value].to_json}</var!>"
+      when 'not_similar'
+        " not similar to <var!>#{values[:value].to_json}</var!>"
+      when 'similar'
+        " similar to <var!>#{values[:value].to_json}</var!>"
+      else
+        ''
+      end
+    end
+
+    def redefine_values(expression)
+      values = {}
+      variables = expression.scan(/<var!>(.+?)<\/var!>/i).flatten.uniq
+      for i in 0..(variables.count-1) do
+        values["v#{i}".to_sym] = JSON.parse(variables[i])
+        expression = expression.gsub("<var!>#{variables[i]}</var!>", ":v#{i}")
+      end
+      [expression, values]
+    end
+
+    # https://stackoverflow.com/questions/5826210/rails-order-with-nulls-last
+    def case_sort(field, sort_direction)
+      case sort_direction
+      when 'asc'
+        "#{field} asc"
+      when 'asc_nulls_first'
+        "CASE WHEN #{field} IS NOT NULL THEN 1 ELSE 0 END, #{field} ASC"
+      when 'asc_nulls_last'
+        "CASE WHEN #{field} IS NULL THEN 1 ELSE 0 END, #{field} ASC"
+      when 'desc'
+        "#{field} desc"
+      when 'desc_nulls_first'
+        "CASE WHEN #{field} IS NOT NULL THEN 1 ELSE 0 END, #{field} DESC"
+      when 'desc_nulls_last'
+        "CASE WHEN #{field} IS NULL THEN 1 ELSE 0 END, #{field} DESC"
+      else
+        ''
+      end
+    end
+
+  end
+end

data/lib/generators/templates/app/graphql/resolvers/table_search.rb

@@ -0,0 +1,68 @@
+require 'search_object/plugin/graphql'
+
+class Resolvers::<%= plural_name_camelized %>Search < Resolvers::BaseSearchResolver
+
+  # scope is starting point for search
+  scope { <%= singular_name_camelized %>.all }
+
+  type types[Types::<%= singular_name_camelized %>Type]
+
+  ### Pagination
+  option :first, type: types.Int, with: :apply_first
+  option :skip, type: types.Int, with: :apply_skip
+
+  def apply_first(scope, value)
+    scope.limit(value)
+  end
+
+  def apply_skip(scope, value)
+    scope.offset(value)
+  end
+
+  ### Order by
+  class <%= plural_name_camelized %>OrderBy < ::Types::BaseInputObject
+    argument :field, Types::Enums::<%= plural_name_camelized %>Field, required: false
+    argument :sortDirection, Types::Enums::SortDir, required: false
+  end
+
+  option :sort_by, type: types[<%= plural_name_camelized %>OrderBy], with: :apply_sort_by
+
+  def apply_sort_by(scope, value)
+    scope.order( value.map{|arg| 
+      Types::Enums::<%= plural_name_camelized %>Field.values.include?(arg[:field]) ? case_sort(arg[:field], arg[:sort_direction]) : ''
+    }.join(', ') )
+  end
+
+
+  ### Distinct
+  option :distinct_on, type: types[Types::Enums::<%= plural_name_camelized %>Field], with: :apply_distinct_on
+
+  def apply_distinct_on(scope, value)
+    scope.select("distinct on (#{value.uniq.join(', ')}) *")
+  end
+
+
+  ### Booleans
+<% for attribute in columns_types -%>
+<% if attribute[:type] == 'Boolean' -%>
+  option(:<%= attribute[:name] %>, type: types.Boolean, description: 'Filter for <%= attribute[:name] %>') { |scope, value| scope.where(<%= attribute[:name] %>: value)}
+<% end -%>
+<% end -%>
+
+  ### Filter
+  class <%= plural_name_camelized %>WhereExp < ::Types::BaseInputObject
+    argument :_or, [self], required: false
+    argument :_and, [self], required: false
+    argument :_not, [self], required: false
+    argument :field, Types::Enums::<%= plural_name_camelized %>Field, required: false
+    argument :operator, Types::Enums::Operator, required: false
+    argument :value, [String], required: false
+  end
+
+  option :where, type: types[<%= plural_name_camelized %>WhereExp], with: :apply_filter
+
+  def apply_filter(scope, value)
+    where == '()' ? scope : scope.where(query_where(value))
+  end
+
+end

data/lib/generators/templates/app/graphql/types/base_field.rb

@@ -0,0 +1,7 @@
+module Types
+  class BaseField < GraphQL::Schema::Field
+    def resolve_field(obj, args, ctx)
+      resolve(obj, args, ctx)
+    end
+  end
+end

data/lib/generators/templates/app/graphql/types/date_time_type.rb

@@ -0,0 +1,6 @@
+Types::DateTimeType = GraphQL::ScalarType.define do
+  name 'DateTime'
+
+  coerce_input ->(value, _ctx) { Time.zone.parse(value) }
+  coerce_result ->(value, _ctx) { value.utc.iso8601 }
+end

data/lib/generators/templates/app/graphql/types/enums/operator.rb

@@ -0,0 +1,22 @@
+module Types
+  module Enums
+    class Operator < Types::BaseEnum
+      description 'Comparison Operators'
+      value('equal', 'Equal')
+      value('greater_than', 'Greater than')
+      value('greater_than_or_equal_to', 'Greater than or equal')
+      value('ilike', 'Case insensitive Text search')
+      value('in', 'In list')
+      value('is_null', 'Is Null')
+      value('like', 'Case sensitive Text search')
+      value('less_than',  'Less than')
+      value('less_than_or_equal_to', 'Less than or equal')
+      value('not_equal', 'Not Equal')
+      value('not_ilike', 'Case insensitive Text search negative')
+      value('not_in', 'Not in list')
+      value('not_like', 'Case sensitive Text search negative')
+      value('not_similar', 'Not Similar to Regular Expressions')
+      value('similar', 'Similar to Regular Expressions')
+    end
+  end
+end

data/lib/generators/templates/app/graphql/types/enums/sort_dir.rb

@@ -0,0 +1,13 @@
+module Types
+  module Enums
+    class SortDir < Types::BaseEnum
+      description 'Column ordering options'
+      value('asc', 'in the ascending order, nulls last')
+      value('asc_nulls_first', 'in the ascending order, nulls first')
+      value('asc_nulls_last', 'in the ascending order, nulls last')
+      value('desc', 'in the descending order, nulls last')
+      value('desc_nulls_first', 'in the descending order, nulls first')
+      value('desc_nulls_last', 'in the descending order, nulls last')
+    end
+  end
+end

data/lib/generators/templates/app/graphql/types/enums/table_field.rb

@@ -0,0 +1,10 @@
+module Types
+  module Enums
+    class <%= plural_name_camelized %>Field < Types::BaseEnum
+      description 'Fields from table <%= plural_name %>'
+<% for attribute in columns_types -%>
+      value("<%= attribute[:name] %>")
+<% end -%>
+    end
+  end
+end

data/lib/generators/templates/app/graphql/types/table_type.rb

@@ -0,0 +1,5 @@
+class Types::<%= singular_name_camelized %>Type < Types::BaseObject
+<% for attribute in columns_types -%>
+  field :<%= attribute[:name] %>, <%= attribute[:name] == primary_key ? 'ID' : attribute[:type] %>, null: <%= attribute[:null] %>
+<% end -%>
+end

data/lib/generators/templates/test/integration/graphql_1st_test.rb

@@ -0,0 +1,9 @@
+require 'test_helper'
+
+class Graphql1stTest < ActionDispatch::IntegrationTest
+    test "can see the graphql endpoint" do
+      post '/graphql', params: {}
+      assert_response :success
+      assert_equal response.body, '{"errors":[{"message":"No query string was present"}]}'
+    end
+end

data/lib/generators/templates/test/integration/graphql_table_test.rb

@@ -0,0 +1,119 @@
+require 'test_helper'
+
+class Graphql<%= plural_name_camelized %>Test < ActionDispatch::IntegrationTest
+  setup do
+    @<%= singular_name_snaked %> = <%= plural_name_snaked %>(:one)
+  end
+
+  test "can see a result" do
+    gql = <<-GRAPHQL
+      {
+        <%= list_many %>(first: 10, sort_by: {field: <%= columns_type_without_primary_key.sample[:name] %>, sortDirection: asc}) {
+<% for attribute in columns_types -%>
+            <%= attribute[:name] %>
+<% end -%>
+        }
+      }
+    GRAPHQL
+
+    post '/graphql', params: {query: gql}
+    assert_response :success
+    json = JSON.parse(response.body)
+    assert_not_empty json['data']
+    assert_not_empty json['data']['<%= list_many %>']
+  end
+
+  test "can add a record" do
+    gql = <<-GRAPHQL
+      mutation a {
+        <%= create_one %>(input: {
+<% for attribute in columns_type_without_primary_key -%>
+          <%= attribute[:name] %>: "<%= attribute[:sample] %>",
+<% end -%>
+          clientMutationId: "test-1"
+        } ) 
+        {
+          <%= singular_name_snaked %> {
+<% for attribute in columns_types -%>
+            <%= attribute[:name] %>
+<% end -%>
+          }
+          clientMutationId
+          errors
+        }
+      }
+    GRAPHQL
+    post '/graphql', params: {query: gql}
+    assert_response :success
+    json = JSON.parse(response.body)
+    #puts response.body
+    
+    assert_not_empty json['data']
+    assert_not_empty json['data']['<%= create_one %>']
+    assert_not_empty json['data']['<%= create_one %>']['<%= singular_name_snaked %>']
+    assert_empty json['data']['<%= create_one %>']['errors']
+
+    <%= primary_key %> = json['data']['<%= create_one %>']['<%= singular_name_snaked %>']['<%= primary_key %>']
+    assert_not_empty <%= singular_name_camelized %>.where(<%= primary_key %>: <%= primary_key %>)
+  end
+
+  test "can change a record" do
+    <%= primary_key %> = <%= singular_name_camelized %>.last.<%= primary_key %>
+    gql = <<-GRAPHQL
+      mutation a {
+        <%= change_one %>(input: {
+          <%= primary_key %>: "#{<%= primary_key %>}", 
+<% for attribute in columns_type_without_primary_key -%>
+          <%= attribute[:name] %>: "<%= attribute[:sample] %>",
+<% end -%>
+          clientMutationId: "test-2"} ) 
+        {
+          <%= singular_name_snaked %> {
+<% for attribute in columns_types -%>
+            <%= attribute[:name] %>
+<% end -%>
+          }
+          clientMutationId
+          errors
+        }
+      }
+    GRAPHQL
+
+    post '/graphql', params: {query: gql}
+    assert_response :success
+    json = JSON.parse(response.body)
+    assert_not_empty json['data']
+    assert_not_empty json['data']['<%= change_one %>']
+    assert_empty json['data']['<%= change_one %>']['errors']
+
+    assert_equal <%= singular_name_camelized %>.find(id).url, json['data']['<%= change_one %>']['<%= singular_name_snaked %>']['url']
+  end
+
+  test "can destroy a record" do
+    <%= primary_key %> = <%= singular_name_camelized %>.last.<%= primary_key %>
+    gql = <<-GRAPHQL
+      mutation a {
+        <%= destroy_one %>(input: {<%= primary_key %>: "#{<%= primary_key %>}", clientMutationId: "test-3"} ) 
+        {
+          <%= singular_name_snaked %> {
+<% for attribute in columns_types -%>
+            <%= attribute[:name] %>
+<% end -%>
+          }
+          clientMutationId
+          errors
+        }
+      }
+    GRAPHQL
+
+    post '/graphql', params: {query: gql}
+    assert_response :success
+    json = JSON.parse(response.body)
+    assert_not_empty json['data']
+    assert_not_empty json['data']['<%= destroy_one %>']
+    assert_empty json['data']['<%= destroy_one %>']['errors']
+
+    assert_empty <%= singular_name_camelized %>.where(<%= primary_key %>: <%= primary_key %>)
+  end
+
+end

data/lib/graphql_scaffold/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module GraphqlScaffold
+  VERSION = '0.0.1'
+end

data/lib/graphql_scaffold.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+require 'graphql_scaffold/version'
+
+module GraphqlScaffold
+end

data/readme.md

@@ -0,0 +1,36 @@
+# graphql scaffold <img src="https://cloud.githubusercontent.com/assets/2231765/9094460/cb43861e-3b66-11e5-9fbf-71066ff3ab13.png" height="40" alt="graphql-ruby"/>
+
+[![Build Status](https://travis-ci.org/arthurmolina/graphql-ruby.svg?branch=master)](https://travis-ci.org/arthurmolina/graphql_scaffold)
+[![Gem Version](https://badge.fury.io/rb/graphql_scaffold.svg)](https://rubygems.org/gems/graphql_scaffold)
+[![GitHub](https://img.shields.io/github/license/arthurmolina/graphql_scaffold)](https://img.shields.io/github/license/arthurmolina/graphql_scaffold)
+
+Rails generator for scaffolding models with [GraphQL-Ruby](https://github.com/rmosolgo/graphql-ruby/).
+
+## Installation
+
+Install from RubyGems by adding it to your `Gemfile`, then bundling.
+
+```ruby
+# Gemfile
+gem 'graphql_scaffold'
+```
+
+```
+$ bundle install
+```
+
+## Usage
+
+If you have a model already created:
+
+```
+$ rails generate graphql_scaffold model_example
+```
+
+If you want to create a model and scaffold your Graphql API:
+
+```
+$ rails generate graphql_scaffold model_example field1 field2:integer field3
+```
+
+After this, you may need to run `rails db:migrate`. The format for fields are the same as rails generate model.

metadata

@@ -0,0 +1,64 @@
+--- !ruby/object:Gem::Specification
+name: graphql_scaffold
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Arthur Molina
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2019-11-19 00:00:00.000000000 Z
+dependencies: []
+description: 
+email:
+- arthurmolina@yahoo.com.br
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE
+- lib/generators/graphql_scaffold_common_methods.rb
+- lib/generators/graphql_scaffold_generator.rb
+- lib/generators/templates/app/graphql/mutations/base_mutation.rb
+- lib/generators/templates/app/graphql/mutations/change_table.rb
+- lib/generators/templates/app/graphql/mutations/create_table.rb
+- lib/generators/templates/app/graphql/mutations/destroy_table.rb
+- lib/generators/templates/app/graphql/resolvers/base_search_resolver.rb
+- lib/generators/templates/app/graphql/resolvers/table_search.rb
+- lib/generators/templates/app/graphql/types/base_field.rb
+- lib/generators/templates/app/graphql/types/date_time_type.rb
+- lib/generators/templates/app/graphql/types/enums/operator.rb
+- lib/generators/templates/app/graphql/types/enums/sort_dir.rb
+- lib/generators/templates/app/graphql/types/enums/table_field.rb
+- lib/generators/templates/app/graphql/types/table_type.rb
+- lib/generators/templates/test/integration/graphql_1st_test.rb
+- lib/generators/templates/test/integration/graphql_table_test.rb
+- lib/graphql_scaffold.rb
+- lib/graphql_scaffold/version.rb
+- readme.md
+homepage: https://arthurmolina.com
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+- lib/generators
+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: []
+rubygems_version: 3.0.6
+signing_key: 
+specification_version: 4
+summary: A good way to automatize graphql models
+test_files: []