graphql_model_mapper 0.0.2

data/lib/graphql_model_mapper/mapper_type.rb

@@ -0,0 +1,340 @@
+module GraphqlModelMapper
+    module MapperType
+        def self.graphql_types(
+            name: self.name,
+            query: {},
+            update: {},
+            delete: {},
+            create: {}
+            )
+            typesuffix = method(__method__).parameters.map { |arg| eval arg[1].to_s }.hash.abs.to_i.to_s
+            return GraphqlModelMapper.get_constant("#{name.upcase}#{typesuffix}_GRAPHQL_DEFAULT_TYPES") if GraphqlModelMapper.const_defined?("#{name.upcase}#{typesuffix}_GRAPHQL_DEFAULT_TYPES") 
+              
+            graphql_type = {}
+            graphql_type[:query] = query
+            graphql_type[:update] = update
+            graphql_type[:delete] = delete
+            graphql_type[:create] = create
+            merged_graphql_type = self.graphql_default_types.deep_merge(graphql_type)
+            GraphqlModelMapper.set_constant("#{name.upcase}#{typesuffix}_GRAPHQL_DEFAULT_TYPES", merged_graphql_type)
+
+            merged_graphql_type
+        end
+
+
+        def self.get_ar_object_with_params(name, type_key: nil, type_sub_key: nil)
+            self.get_ar_object(name, self.get_type_params(name, type_key: type_key, type_sub_key: type_sub_key))
+        end
+        
+        def self.get_ar_object(name, 
+            required_attributes: [], 
+            excluded_attributes: [], 
+            allowed_attributes: [],
+            foreign_keys: false, 
+            primary_keys: false, 
+            validation_keys: false, 
+            association_macro: nil, 
+            source_nulls: true,
+            type_key: nil,
+            type_sub_key: nil)
+        
+            
+            #typesuffix = method(__method__).parameters.map { |arg| eval arg[1].to_s }.hash.abs.to_i.to_s
+            typesuffix = "#{type_key.to_s.classify}#{GraphqlModelMapper.underscore(type_sub_key.to_s)}".camelize
+            typename = "#{GraphqlModelMapper.get_type_name(name)}#{typesuffix}"
+            
+            return GraphqlModelMapper.get_constant(typename) if GraphqlModelMapper.defined_constant?(typename)
+        
+            model = name.classify.constantize
+        
+            required_attributes = required_attributes.map(&:to_sym) | (validation_keys ? self.model_validation_keys(name) : [])
+            
+            columns = model.columns_hash
+        
+            # figure out which association fields we are exposing
+            association_includes =  (model.reflect_on_all_associations(association_macro).map(&:name)).map(&:to_sym) - excluded_attributes 
+        
+            # find all relations for this model, skip ones where the association klass is invalid, as well as polymorphic associations, be cognizant of include/exclude arrays similar to dbfields
+            associations = model.reflect_on_all_associations(association_macro).select{|t| begin t.klass rescue next end}.select{|t| !t.options[:polymorphic] && association_includes.include?(t.name.to_sym) } 
+            # never show foreign keys for defined associations
+            db_fields_never = foreign_keys ? [] : ( associations.map(&:association_foreign_key) + associations.map(&:options).select{|v| v.key?(:foreign_key) }.map {|x| x[:foreign_key]} ).uniq.map(&:to_sym)
+                
+            # figure out which database fields we are exposing
+            allowed_attributes = allowed_attributes.count > 0 ? allowed_attributes.map(&:to_sym) : associations.map(&:name) + columns.keys.map(&:to_sym)
+            allowed_associations = (associations.map(&:name) - excluded_attributes - db_fields_never) & allowed_attributes
+            db_fields = (columns.keys.map(&:to_sym) - excluded_attributes - db_fields_never) & allowed_attributes
+            associations = associations.select{|m| allowed_associations.include?(m.name)}
+                
+            ret_type = GraphQL::InputObjectType.define do
+                #ensure type name is unique  so it does not collide with known types
+                name typename
+                description "an input interface for the #{name} ActiveRecord model"
+                # create GraphQL fields for each exposed database field
+                db_fields.select{|s| (primary_keys && s.to_sym == :id)}.each do |f|
+                    argument f.to_sym, -> {GraphqlModelMapper::MapperType.convert_type(columns[f.to_s].type, columns[f.to_s].sql_type, (source_nulls ? columns[f.to_s].null : true))}
+                end       
+                db_fields.select{|s| required_attributes.include?(s)}.each do |f|
+                    argument f.to_sym, -> {GraphqlModelMapper.convert_type(columns[f.to_s].type, columns[f.to_s].sql_type, false)}
+                end       
+                # create GraphQL fields for each association
+                associations.sort_by(&:name).each do |reflection|
+                    begin
+                        klass = reflection.klass
+                    rescue
+                        next # most likely an invalid association without a class name, skip if other errors are encountered
+                    end                    
+                    if reflection.macro == :has_many
+                        argument reflection.name.to_sym, -> {GraphqlModelMapper::MapperType.get_ar_object_with_params(klass.name, type_key: type_key, type_sub_key: type_sub_key).to_list_type} do
+                            if GraphqlModelMapper.use_authorize
+                                authorized ->(ctx, model_name, access_type) { GraphqlModelMapper.authorized?(ctx, model_name, access_type.to_sym) }
+                                model_name klass.name
+                                access_type type_key.to_s
+                            end
+                        end   
+                    else
+                        argument reflection.name.to_sym, -> {GraphqlModelMapper::MapperType.get_ar_object_with_params(klass.name, type_key: type_key, type_sub_key: type_sub_key)} do
+                            if GraphqlModelMapper.use_authorize
+                                authorized ->(ctx, model_name, access_type) { GraphqlModelMapper.authorized?(ctx, model_name, access_type.to_sym) }
+                                model_name klass.name
+                                access_type type_key.to_s
+                            end
+                        end   
+                    end                
+                end
+        
+                db_fields.reject{|s| (primary_keys && s.to_sym == :id) || required_attributes.include?(s)}.sort.each do |f|
+                    argument f.to_sym, -> {GraphqlModelMapper::MapperType.convert_type(columns[f.to_s].type, columns[f.to_s].sql_type, (source_nulls ? columns[f.to_s].null : true))}
+                end
+            end if type_sub_key == :input_type
+        
+            ret_type = GraphQL::ObjectType.define do
+                #ensure type name is unique  so it does not collide with known types
+                name typename
+                description "an output interface for the #{name} ActiveRecord model"
+                # create GraphQL fields for each exposed database field
+                db_fields.select{|s| (primary_keys && s.to_sym == :id)}.each do |f|
+                    #puts "source null #{f} #{source_nulls ? columns[f.to_s].null : true}"
+                    field f.to_sym, -> {GraphqlModelMapper::MapperType.convert_type(columns[f.to_s].type, columns[f.to_s].sql_type, (source_nulls ? columns[f.to_s].null : true))}
+                end       
+                db_fields.select{|s| required_attributes.include?(s)}.sort.each do |f|
+                    field f.to_sym, -> {GraphqlModelMapper::MapperType.convert_type(columns[f.to_s].type, columns[f.to_s].sql_type, false)}
+                end       
+            # create GraphQL fields for each association
+                associations.sort_by(&:name).each do |reflection|
+                    begin
+                        klass = reflection.klass
+                    rescue
+                        next # most likely an invalid association without a class name, skip if other errors are encountered
+                    end                    
+                    if reflection.macro == :has_many
+                        if [:deep].include?(GraphqlModelMapper.nesting_strategy) && type_key == :query
+                            connection reflection.name.to_sym, -> {GraphqlModelMapper::MapperType.get_ar_object_with_params(klass.name, type_key: type_key, type_sub_key: type_sub_key).connection_type} do
+                                if GraphqlModelMapper.use_authorize
+                                    authorized ->(ctx, model_name, access_type) { GraphqlModelMapper.authorized?(ctx, model_name, access_type.to_sym) }
+                                    model_name klass.name
+                                    access_type :read.to_s
+                                end
+                            end 
+                        else
+                            field reflection.name.to_sym, -> {GraphqlModelMapper::MapperType.get_ar_object_with_params(klass.name, type_key: type_key, type_sub_key: type_sub_key).to_list_type} do
+                                if GraphqlModelMapper.use_authorize
+                                    authorized ->(ctx, model_name, access_type) { GraphqlModelMapper.authorized?(ctx, model_name, access_type.to_sym) }
+                                    model_name klass.name
+                                    access_type :read.to_s
+                                end
+                            end    
+                        end
+                    else
+                        field reflection.name.to_sym, -> {GraphqlModelMapper::MapperType.get_ar_object_with_params(klass.name, type_key: type_key, type_sub_key: type_sub_key)} do
+                            if GraphqlModelMapper.use_authorize
+                                authorized ->(ctx, model_name, access_type) { GraphqlModelMapper.authorized?(ctx, model_name, access_type.to_sym) }
+                                model_name klass.name
+                                access_type :read.to_s
+                            end
+                        end   
+                    end
+                end                        
+                db_fields.reject{|s| (primary_keys && s.to_sym == :id) || required_attributes.include?(s)}.sort.each do |f|
+                    #puts "source null #{f} #{source_nulls ? columns[f.to_s].null : true}"
+                    field f.to_sym, -> {GraphqlModelMapper::MapperType.convert_type(columns[f.to_s].type, columns[f.to_s].sql_type, (source_nulls ? columns[f.to_s].null : true))}
+                end
+            end if type_sub_key == :output_type
+            GraphqlModelMapper.set_constant(typename, ret_type) if !GraphqlModelMapper.defined_constant?(typename)
+            ret_type
+        end
+    
+        def self.get_type_params(name, type_key: nil, type_sub_key: nil)
+            model = name.classify.constantize
+            if model.public_methods.include?(:graphql_types)
+                params = model.graphql_types
+            else
+                params = self.graphql_default_types
+            end
+            #puts params
+            if !type_key.nil?
+                if params.keys.include?(type_key.to_sym)
+                params = params[type_key.to_sym]
+                if !type_sub_key.nil?
+                    if params.keys.include?(type_sub_key.to_sym)
+                    params = params[type_sub_key.to_sym]
+                    else
+                    params = nil
+                    end
+                end
+                else
+                params = nil
+                end
+            end
+            params 
+        end
+    
+        def self.graphql_default_types(
+            query: {
+            input_type: {
+                required_attributes: [], 
+                excluded_attributes: [], 
+                allowed_attributes: [], 
+                foreign_keys: true, 
+                primary_keys: true, 
+                validation_keys: false, 
+                association_macro: nil, 
+                source_nulls: false,
+                type_key: :query,
+                type_sub_key: :input_type
+            },
+            output_type: {
+                required_attributes: [], 
+                excluded_attributes: [], 
+                allowed_attributes: [], 
+                foreign_keys: true, 
+                primary_keys: true, 
+                validation_keys: false, 
+                association_macro: nil, 
+                source_nulls: false,
+                type_key: :query,
+                type_sub_key: :output_type
+            }
+            },
+            update: {
+            input_type: {
+                required_attributes: [], 
+                excluded_attributes: [], 
+                allowed_attributes: [], 
+                foreign_keys: true, 
+                primary_keys: true, 
+                validation_keys: false, 
+                association_macro: nil, 
+                source_nulls: false,
+                type_key: :update,
+                type_sub_key: :input_type
+            },
+            output_type: {
+                required_attributes: [], 
+                excluded_attributes: [], 
+                allowed_attributes: [], 
+                foreign_keys: true, 
+                primary_keys: true, 
+                validation_keys: false, 
+                association_macro: nil, 
+                source_nulls: true,
+                type_key: :update,
+                type_sub_key: :output_type
+            }
+            },
+            delete: {
+            input_type: {
+                required_attributes: [:id], 
+                excluded_attributes: [], 
+                allowed_attributes: [:id], 
+                foreign_keys: false, 
+                primary_keys: true, 
+                validation_keys: false, 
+                association_macro: nil, 
+                source_nulls: false,
+                type_key: :delete,
+                type_sub_key: :input_type
+            },
+            output_type: {
+                required_attributes: [], 
+                excluded_attributes: [], 
+                allowed_attributes: [], 
+                foreign_keys: false, 
+                primary_keys: true, 
+                validation_keys: false, 
+                association_macro: nil, 
+                source_nulls: true,
+                type_key: :delete,
+                type_sub_key: :output_type
+            }
+            },
+            create: {
+            input_type: {
+                required_attributes: [], 
+                excluded_attributes: [], 
+                allowed_attributes: [], 
+                foreign_keys: true, 
+                primary_keys: false, 
+                validation_keys: false, 
+                association_macro: :has_many, 
+                source_nulls: false,
+                type_key: :create,
+                type_sub_key: :input_type
+            },
+            output_type: {
+                required_attributes: [], 
+                excluded_attributes: [], 
+                allowed_attributes: [], 
+                foreign_keys: true, 
+                primary_keys: true, 
+                validation_keys: false, 
+                association_macro: nil, 
+                source_nulls: true,
+                type_key: :create,
+                type_sub_key: :output_type
+            }
+            })
+            return GraphqlModelMapper.get_constant("GRAPHQL_DEFAULT_TYPES") if GraphqlModelMapper.const_defined?("GRAPHQL_DEFAULT_TYPES") 
+                
+            graphql_type = {}
+            graphql_type[:query] = query
+            graphql_type[:update] = update
+            graphql_type[:delete] = delete
+            graphql_type[:create] = create
+        
+            GraphqlModelMapper.set_constant("GRAPHQL_DEFAULT_TYPES", graphql_type)
+            graphql_type
+        end
+    
+        def self.model_validation_keys(name)
+            model = name.classify.constantize
+            validation_attributes = model.validators.select{|m| m.is_a?(ActiveModel::Validations::PresenceValidator) && !m.options[:if]}.map(&:attributes).flatten
+            model.reflect_on_all_associations.select{|p| validation_attributes.include?(p.name) }.map(&:foreign_key).map(&:to_sym)  | validation_attributes & model.columns_hash.keys.map(&:to_sym)
+        end
+
+        # convert a database type to a GraphQL type
+        # @param db_type [Symbol] the type returned by columns_hash[column_name].type
+        # @param db_sql_type [String] the sql_type returned by columns_hash[column_name].sql_type
+        # @return [GraphQL::ScalarType] a GraphQL type
+        def self.convert_type db_type, db_sql_type="", nullable=true
+            # because we are outside of a GraphQL define block we cannot use the types helper
+            # we must refer directly to the built-in GraphQL scalar types
+            case db_type
+            when :integer
+                nullable ? GraphQL::INT_TYPE : !GraphQL::INT_TYPE
+            when :decimal, :float
+                nullable ? GraphQL::FLOAT_TYPE : !GraphQL::FLOAT_TYPE
+            when :boolean
+                nullable ? GraphQL::BOOLEAN_TYPE : !GraphQL::BOOLEAN_TYPE
+            when :date, :datetime
+                nullable ? GraphqlModelMapper::DATE_TYPE : !GraphqlModelMapper::DATE_TYPE
+            else
+                case db_sql_type.to_sym #these are strings not symbols
+                when :geometry, :multipolygon, :polygon
+                    nullable ? GraphqlModelMapper::GEOMETRY_TYPE : !GraphqlModelMapper::GEOMETRY_TYPE
+                else
+                    nullable ? GraphQL::STRING_TYPE : !GraphQL::STRING_TYPE
+                end
+            end
+        end
+    end
+end    

data/lib/graphql_model_mapper/mutation.rb

@@ -0,0 +1,125 @@
+module GraphqlModelMapper
+    module Mutation
+        def self.graphql_update(name: "",description:"",
+            resolver: nil)
+      
+      
+            input_type = GraphqlModelMapper::MapperType.get_ar_object_with_params(name, type_key: :update, type_sub_key: :input_type)
+            output_type = GraphqlModelMapper::MapperType.get_ar_object_with_params(name, type_key: :update, type_sub_key: :output_type)
+      
+            self.get_mutation(name, description, "Update", resolver, input_type, output_type, name.downcase, "item")
+          end
+          
+          def self.graphql_delete(name: "", description:"",
+            resolver: nil,
+            arguments: [],
+            scope_methods: [])
+            
+            input_type = GraphqlModelMapper::MapperType.get_ar_object_with_params(name, type_key: :delete, type_sub_key: :input_type)
+            output_type = GraphqlModelMapper::MapperType.get_ar_object_with_params(name, type_key: :delete, type_sub_key: :output_type).to_list_type
+            self.get_delete_mutation(name, description, "Delete", resolver, arguments, scope_methods, input_type, output_type)
+          end
+          
+          def self.graphql_create(name: "", description:"",
+            resolver: nil)
+            
+            input_type = GraphqlModelMapper::MapperType.get_ar_object_with_params(name, type_key: :create, type_sub_key: :input_type)
+            output_type = GraphqlModelMapper::MapperType.get_ar_object_with_params(name, type_key: :create, type_sub_key: :output_type)
+      
+            self.get_mutation(name, description, "Create", resolver, input_type, output_type, name.downcase, "item")
+          end
+
+          def self.get_mutation(name, description, operation_name, resolver, input_type, output_type, input_name, output_name)
+            mutation_type_name = GraphqlModelMapper.get_type_case("#{GraphqlModelMapper.get_type_name(name)}#{operation_name}")
+            return GraphqlModelMapper.get_constant(mutation_type_name) if GraphqlModelMapper.defined_constant?(mutation_type_name)
+            mutation_type = GraphQL::Relay::Mutation.define do
+              name mutation_type_name
+              description description
+              input_field input_name.to_sym, -> {input_type}
+              return_field output_name.to_sym, -> {output_type}
+        
+              resolve resolver
+            end
+        
+            GraphqlModelMapper.set_constant(mutation_type_name, mutation_type.field)
+            GraphqlModelMapper.get_constant(mutation_type_name)
+        end
+
+        def self.get_delete_mutation(name, description, operation_name, resolver, arguments, scope_methods, input_type, output_type)            
+            query_type_name = GraphqlModelMapper.get_type_case("#{GraphqlModelMapper.get_type_name(name)}#{operation_name}")
+            return GraphqlModelMapper.get_constant(query_type_name) if GraphqlModelMapper.defined_constant?(query_type_name) 
+            
+            model = name.classify.constantize
+    
+            default_arguments = self.get_default_select_arguments(model, scope_methods)
+            select_input_type_name = GraphqlModelMapper.get_type_case("#{GraphqlModelMapper.get_type_name(name)}SelectInput")     
+            if GraphqlModelMapper.defined_constant?(select_input_type_name)
+            query_input_object_type = GraphqlModelMapper.get_constant(select_input_type_name)
+            else
+            query_input_object_type = GraphQL::InputObjectType.define do
+                name select_input_type_name
+                default_arguments.each do |k|
+                argument k[:name].to_sym, k[:type], k[:description], default_value: k[:default] 
+                end
+            end
+            GraphqlModelMapper.set_constant(select_input_type_name, query_input_object_type)
+            end
+        
+            
+            ret_type = GraphQL::Relay::Mutation.define do
+                name query_type_name
+                #return_field :item, output_object_type
+                return_field :items, output_type
+                return_field :total, -> {GraphQL::INT_TYPE}
+    
+                #description description
+                #input_field "input".to_sym, -> {input_object_type}
+                input_field :select, -> {!query_input_object_type}
+        
+                resolve resolver 
+            end
+            GraphqlModelMapper.set_constant(query_type_name, ret_type.field)
+            GraphqlModelMapper.get_constant(query_type_name)
+        end
+
+        def self.get_default_select_arguments(model, scope_methods)
+            default_arguments = [
+              {:name=>:explain,   :type=>GraphQL::BOOLEAN_TYPE, :default=>nil}, 
+              {:name=>:id,    :type=>GraphQL::INT_TYPE, :default=>nil}, 
+              {:name=>:ids,    :type=>GraphQL::INT_TYPE.to_list_type, :default=>nil}, 
+              {:name=>:limit, :type=>GraphQL::INT_TYPE, :default=>50},
+              {:name=>:offset, :type=>GraphQL::INT_TYPE, :default=>nil},
+              {:name=>:order,   :type=>GraphQL::STRING_TYPE, :default=>nil}, 
+              {:name=>:where, :type=>GraphQL::STRING_TYPE.to_list_type, :default=>nil}
+            ]
+        
+            scope_methods = scope_methods.map(&:to_sym)                        
+            #.select{|m| model.method(m.to_sym).arity == 0}
+            if (model.public_methods - model.instance_methods - Object.methods - ActiveRecord::Base.methods).include?(:with_deleted)
+              default_arguments << {:name=>:with_deleted, :type=>GraphQL::BOOLEAN_TYPE, :default=>false}
+            end
+            allowed_scope_methods = []
+            if scope_methods.count > 0
+              scope_methods.each do |s|
+                #.select{|m| model.method(m.to_sym).arity == 0}
+                allowed_scope_methods << s if (model.public_methods - model.instance_methods - Object.methods - ActiveRecord::Base.methods).include?(s)
+              end
+              if allowed_scope_methods.count > 0
+                typename = GraphqlModelMapper.get_type_case("#{GraphqlModelMapper.get_type_name(model.name)}Scope_Enum")
+                if !GraphqlModelMapper.defined_constant?(typename)
+                  enum_type = GraphQL::EnumType.define do
+                    name typename
+                    description "scope enum for #{GraphqlModelMapper.get_type_name(model.name)}"
+                    allowed_scope_methods.sort.each do |s|
+                      value(s, "")
+                    end
+                  end
+                  GraphqlModelMapper.set_constant typename, enum_type
+                end
+                default_arguments << {:name=>:scope, :type=>GraphqlModelMapper.get_constant(typename), :default=>nil}
+              end
+            end
+            default_arguments
+        end          
+    end
+end    

data/lib/graphql_model_mapper/query.rb

@@ -0,0 +1,107 @@
+module GraphqlModelMapper
+    module Query
+        def self.graphql_query(name: "",
+            description: "",
+            resolver: nil,
+            arguments: [],
+            scope_methods: []
+          )
+          
+            input_type = GraphqlModelMapper::MapperType.get_ar_object_with_params(name, type_key: :query, type_sub_key: :input_type)
+            output_type = GraphqlModelMapper::MapperType.get_ar_object_with_params(name, type_key: :query, type_sub_key: :output_type)
+            self.get_query(name, description, "Query", resolver, arguments, scope_methods, input_type, output_type)
+        end
+
+        def self.get_default_select_arguments(model, scope_methods)
+            default_arguments = [
+              {:name=>:explain,   :type=>GraphQL::BOOLEAN_TYPE, :default=>nil}, 
+              {:name=>:id,    :type=>GraphQL::INT_TYPE, :default=>nil}, 
+              {:name=>:ids,    :type=>GraphQL::INT_TYPE.to_list_type, :default=>nil}, 
+              {:name=>:limit, :type=>GraphQL::INT_TYPE, :default=>50},
+              {:name=>:offset, :type=>GraphQL::INT_TYPE, :default=>nil},
+              {:name=>:order,   :type=>GraphQL::STRING_TYPE, :default=>nil}, 
+              {:name=>:where, :type=>GraphQL::STRING_TYPE.to_list_type, :default=>nil}
+            ]
+        
+            scope_methods = scope_methods.map(&:to_sym)                        
+            #.select{|m| model.method(m.to_sym).arity == 0}
+            if (model.public_methods - model.instance_methods - Object.methods - ActiveRecord::Base.methods).include?(:with_deleted)
+              default_arguments << {:name=>:with_deleted, :type=>GraphQL::BOOLEAN_TYPE, :default=>false}
+            end
+            allowed_scope_methods = []
+            if scope_methods.count > 0
+              scope_methods.each do |s|
+                #.select{|m| model.method(m.to_sym).arity == 0}
+                allowed_scope_methods << s if (model.public_methods - model.instance_methods - Object.methods - ActiveRecord::Base.methods).include?(s)
+              end
+              if allowed_scope_methods.count > 0
+                typename = GraphqlModelMapper.get_type_case("#{GraphqlModelMapper.get_type_name(model.name)}Scope_Enum")
+                if !GraphqlModelMapper.defined_constant?(typename)
+                  enum_type = GraphQL::EnumType.define do
+                    name typename
+                    description "scope enum for #{GraphqlModelMapper.get_type_name(model.name)}"
+                    allowed_scope_methods.sort.each do |s|
+                      value(s, "")
+                    end
+                  end
+                  GraphqlModelMapper.set_constant typename, enum_type
+                end
+                default_arguments << {:name=>:scope, :type=>GraphqlModelMapper.get_constant(typename), :default=>nil}
+              end
+            end
+            default_arguments
+        end
+
+        def self.get_query(name, description, operation_name, resolver, arguments, scope_methods, input_type, output_type)
+            
+            query_type_name = GraphqlModelMapper.get_type_case("#{GraphqlModelMapper.get_type_name(name)}#{operation_name}")
+            return GraphqlModelMapper.get_constant(query_type_name) if GraphqlModelMapper.defined_constant?(query_type_name) 
+            
+            model = name.classify.constantize
+        
+            default_arguments = self.get_default_select_arguments(model, scope_methods)
+            select_input_type_name = "#{GraphqlModelMapper.get_type_case(GraphqlModelMapper.get_type_name(name))}QueryInput"     
+            if GraphqlModelMapper.defined_constant?(select_input_type_name)
+              select_input_type = GraphqlModelMapper.get_constant(select_input_type_name)
+            else
+              select_input_type = GraphQL::InputObjectType.define do
+                name select_input_type_name
+                default_arguments.each do |k|
+                  argument k[:name].to_sym, k[:type], k[:description], default_value: k[:default] 
+                end
+              end
+              GraphqlModelMapper.set_constant(select_input_type_name, select_input_type)
+            end
+        
+            total_output_type_name = "#{GraphqlModelMapper.get_type_name(name)}QueryPayload"
+            if GraphqlModelMapper.defined_constant?(total_output_type_name)
+              total_output_type = GraphqlModelMapper.get_constant(total_output_type_name)
+            else
+              total_output_type = GraphQL::ObjectType.define do
+                name total_output_type_name
+                if [:deep, :shallow].include?(GraphqlModelMapper.nesting_strategy)
+                  connection :items, -> {output_type.connection_type}, hash_key: :items
+                else
+                  field :items, -> {output_type.to_list_type}, hash_key: :items
+                end
+                field :total, -> {GraphQL::INT_TYPE}, hash_key: :total
+              end
+              GraphqlModelMapper.set_constant(total_output_type_name, total_output_type)
+            end
+        
+              
+            ret_type = GraphQL::Field.define do
+                name query_type_name
+                type total_output_type
+                #argument :select, -> {!select_input_type}
+                default_arguments.each do |k|
+                  argument k[:name].to_sym, k[:type], k[:description], default_value: k[:default] 
+                end
+        
+                resolve resolver 
+              end
+            GraphqlModelMapper.set_constant(query_type_name, ret_type)
+            GraphqlModelMapper.get_constant(query_type_name)
+        end
+    end
+end    

data/lib/graphql_model_mapper/railtie.rb

@@ -0,0 +1,8 @@
+module GraphqlModelMapper
+  class Railtie < Rails::Railtie
+    initializer 'Rails logger' do
+      GraphqlModelMapper.logger = Rails.logger
+    end
+  end
+end
+