graphql_model_mapper 0.0.6 → 0.1.0

data/lib/graphql_model_mapper.rb

@@ -1,5 +1,6 @@
 require "graphql"
 require "graphql_model_mapper/mapper_type"
+require "graphql_model_mapper/custom_type"
 require "graphql_model_mapper/mutation"
 require "graphql_model_mapper/query"
 require "graphql_model_mapper/resolve"
@@ -9,14 +10,30 @@ require "graphql_model_mapper/version"
 require 'graphql_model_mapper/railtie' if defined?(Rails)
 
 module GraphqlModelMapper
+  mattr_accessor :query_resolve_wrapper
+  mattr_accessor :mutation_resolve_wrapper
+  mattr_accessor :resolve_wrapper
   mattr_accessor :type_case
   mattr_accessor :nesting_strategy
   mattr_accessor :use_authorize
+  mattr_accessor :max_page_size
+  mattr_accessor :scan_for_polymorphic_associations
+  mattr_accessor :default_nodes_field
+  mattr_accessor :bidirectional_pagination
+  
 
   @@type_case = :camelize
   @@nesting_strategy = :shallow
   @@use_authorize = false
+  @@max_page_size = 100
+  @@scan_for_polymorphic_associations = false
+  @@query_resolve_wrapper = nil
+  @@mutation_resolve_wrapper = nil
+  @@default_nodes_field = false
+  @@bidirectional_pagination = false
   
+
+
   class << self
     attr_writer :logger
 
@@ -36,15 +53,15 @@ module GraphqlModelMapper
 
     protected
     
-    def graphql_types(query: {}, update: {}, delete: {}, create: {})
+    def graphql_types(input_type:{}, output_type:{})
       name = self.name
       define_singleton_method(:graphql_types) do
-        GraphqlModelMapper::MapperType.graphql_types(name: name, query: query, update: update, delete: delete, create: create)
+        GraphqlModelMapper::MapperType.graphql_types(name: name, input_type: input_type, output_type: output_type)
       end
     end
 
     def graphql_update(description:"", resolver: -> (obj, inputs, ctx){
-      item = GraphqlModelMapper::Resolve.update_resolver(obj, inputs, ctx, name)
+        item = GraphqlModelMapper::Resolve.update_resolver(obj, inputs, ctx, name)
         {
           item: item
         }
@@ -58,7 +75,6 @@ module GraphqlModelMapper
     def graphql_delete(description:"", resolver: -> (obj, inputs, ctx){
         items = GraphqlModelMapper::Resolve.delete_resolver(obj, inputs, ctx, name)
         {
-          total: items.length,
           items: items
         }
       }, arguments: [], scope_methods: [])
@@ -69,7 +85,7 @@ module GraphqlModelMapper
     end
     
     def graphql_create(description:"", resolver:  -> (obj, args, ctx){
-      item = GraphqlModelMapper::Resolve.create_resolver(obj, args, ctx, name)
+        item = GraphqlModelMapper::Resolve.create_resolver(obj, args, ctx, name)
         {
           item: item
         }
@@ -82,14 +98,10 @@ module GraphqlModelMapper
 
     def graphql_query(description: "", resolver: -> (obj, args, ctx) {              
         items = GraphqlModelMapper::Resolve.query_resolver(obj, args, ctx, name)
-        {
-          items: items,
-          total: items.length
-        }
       }, arguments: [], scope_methods: [])                      
       name = self.name
       define_singleton_method(:graphql_query) do
-        GraphqlModelMapper::Query.graphql_query(name: name, description: description, resolver: resolver, scope_methods: scope_methods)
+        GraphqlModelMapper::Query.graphql_query(name: name, description: description, resolver: resolver, scope_methods: scope_methods, arguments: arguments)
       end
     end
   end

data/lib/graphql_model_mapper/custom_type.rb

@@ -0,0 +1,4 @@
+module GraphqlModelMapper
+  module CustomType
+  end
+end

data/lib/graphql_model_mapper/mapper_type.rb

@@ -2,29 +2,32 @@ module GraphqlModelMapper
     module MapperType
         def self.graphql_types(
             name: self.name,
-            query: {},
-            update: {},
-            delete: {},
-            create: {}
+            input_type: {},
+            output_type: {}
             )
-            #typesuffix = method(__method__).parameters.map { |arg| eval arg[1].to_s }.hash.abs.to_i.to_s
-            GraphqlModelMapper.logger.info("#{name.upcase}") if GraphqlModelMapper.const_defined?("#{name.upcase}_GRAPHQL_DEFAULT_TYPES")  
-            return GraphqlModelMapper.get_constant("#{name.upcase}_GRAPHQL_DEFAULT_TYPES") if GraphqlModelMapper.const_defined?("#{name.upcase}_GRAPHQL_DEFAULT_TYPES") 
-            #GraphqlModelMapper.logger.info "#{name.upcase}_GRAPHQL_DEFAULT_TYPES"
+            return GraphqlModelMapper::CustomType.const_get("#{name.upcase}_GRAPHQL_DEFAULT_TYPES") if GraphqlModelMapper::CustomType.const_defined?("#{name.upcase}_GRAPHQL_DEFAULT_TYPES") 
             graphql_type = {}
-            graphql_type[:query] = query
-            graphql_type[:update] = update
-            graphql_type[:delete] = delete
-            graphql_type[:create] = create
+            graphql_type[:input_type] = input_type
+            graphql_type[:input_type][:type_sub_key] = :input_type
+            graphql_type[:output_type] = output_type
+            graphql_type[:output_type][:type_sub_key] = :output_type
             merged_graphql_type = self.graphql_default_types.deep_merge(graphql_type)
-            GraphqlModelMapper.set_constant("#{name.upcase}_GRAPHQL_DEFAULT_TYPES", merged_graphql_type)
+            GraphqlModelMapper::CustomType.const_set("#{name.upcase}_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))
+        def self.graph_object(name)
+            if GraphqlModelMapper.implementations.map(&:to_s).include?(name.classify)
+                self.get_ar_object_with_params(name)
+            else
+                name.classify.constantize
+            end
+        end
+
+        def self.get_ar_object_with_params(name, type_sub_key: :output_type)
+            self.get_ar_object(name, self.get_type_params(name, type_sub_key: type_sub_key))
         end
         
         def self.get_ar_object(name, 
@@ -36,12 +39,13 @@ module GraphqlModelMapper
             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
+            #typesuffix = "#{type_key.to_s.classify}#{GraphqlModelMapper.underscore(type_sub_key.to_s)}".camelize
+            typesuffix = "#{GraphqlModelMapper.underscore(type_sub_key.to_s).sub("_Type", "")}".camelize
+            #typesuffix = "#{type_sub_key == :input_type ? '_i' : '_o'}"
             typename = "#{GraphqlModelMapper.get_type_name(name)}#{typesuffix}"
             
             return GraphqlModelMapper.get_constant(typename) if GraphqlModelMapper.defined_constant?(typename)
@@ -55,83 +59,102 @@ module GraphqlModelMapper
             # 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) } 
+            # find all relations for this model, skip ones where the association klass is invalid, 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| association_includes.include?(t.name.to_sym) }
+            # now include polymorphic relations whose association klass is invalid, but is correct 
+            associations = associations + model.reflect_on_all_associations(association_macro).select{|t| t.options[:polymorphic]}.select{|t| 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)
+            db_fields_never = foreign_keys ? [] : ( model.reflect_on_all_associations.map(&:association_foreign_key) + model.reflect_on_all_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)}
-                
+            enums = (Rails.version.split(".").first.to_i >= 4 && Rails.version.split(".").second.to_i >= 1) || (Rails.version.split(".").first.to_i >= 5) ? model.defined_enums.keys : [] 
+            enum_values = (Rails.version.split(".").first.to_i >= 4 && Rails.version.split(".").second.to_i >= 1) || (Rails.version.split(".").first.to_i >= 5) ? model.defined_enums : [] 
+            
             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
+                        klass = reflection.klass if !reflection.options[:polymorphic]
                     rescue
-                        GraphqlModelMapper.logger.warning("invalid relation #{reflection.name} specified on the #{name} model, the relation class does not exist")
+                        GraphqlModelMapper.logger.info("invalid relation #{reflection.name} specified on the #{name} model, the relation class does not exist")
                         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
+                        argument reflection.name.to_sym, -> {GraphqlModelMapper::MapperType.get_ar_object_with_params(klass.name, 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
+                                access_type :read
                             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   
+                        if reflection.options[:polymorphic] #not currently supported as an input type
+                            #if GraphqlModelMapper.scan_for_polymorphic_associations
+                            #    argument reflection.name.to_sym, -> {GraphqlModelMapper::MapperType.get_polymorphic_type(reflection, name, type_sub_key: type_sub_key)}    
+                            #end
+                        else
+                            argument reflection.name.to_sym, -> {GraphqlModelMapper::MapperType.get_ar_object_with_params(klass.name, 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
+                                end
+                            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))}
+                # create GraphQL fields for each exposed database field
+                #if primary keys were requested
+                db_fields.select{|s| (primary_keys && s.to_sym == :id)}.each do |f|
+                    argument "item_id".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
+                argument :id, GraphQL::ID_TYPE       
+                # force required_attributes to be non-null
+                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       
+                #get the rest of the fields that are not primary keys or required fields
+                db_fields.reject{|s| (s.to_sym == :id) || required_attributes.include?(s)}.sort.each do |f|
+                    custom_type_name = "#{name.classify}#{f.to_s.classify}AttributeInput"
+                    if GraphqlModelMapper::CustomType.const_defined?(custom_type_name)
+                        argument f.to_sym, GraphqlModelMapper::CustomType.const_get(custom_type_name)
+                    else
+                        if enums.include?(f.to_s)
+                            argument f.to_sym, -> {GraphqlModelMapper::MapperType.get_enum_object(name, enum_values[f.to_s], f.to_s)}
+                        else
+                            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
                 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
+                model_name name
+                authorized ->(ctx, model_name, access_type) { GraphqlModelMapper.authorized?(ctx, model_name, access_type.to_sym) }
+                access_type :read.to_s
+ 
                 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
+                # create GraphQL fields for each association
                 associations.sort_by(&:name).each do |reflection|
                     begin
-                        klass = reflection.klass
+                        klass = reflection.klass if !reflection.options[:polymorphic]
                     rescue
-                        GraphqlModelMapper.logger.warning("invalid relation #{reflection.name} specified on the #{name} model, the relation class does not exist")
+                        GraphqlModelMapper.logger.info("invalid relation #{reflection.name} specified on the #{name} model, the relation class does not exist")
                         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 [:deep].include?(GraphqlModelMapper.nesting_strategy)
+                            connection reflection.name.to_sym, -> {GraphqlModelMapper::MapperType.get_ar_object_with_params(klass.name, type_sub_key: type_sub_key).connection_type}, property: reflection.name.to_sym, max_page_size: GraphqlModelMapper.max_page_size do
                                 if GraphqlModelMapper.use_authorize
                                     authorized ->(ctx, model_name, access_type) { GraphqlModelMapper.authorized?(ctx, model_name, access_type.to_sym) }
                                     model_name klass.name
@@ -139,7 +162,7 @@ module GraphqlModelMapper
                                 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
+                            field reflection.name.to_sym, -> {GraphqlModelMapper::MapperType.get_ar_object_with_params(klass.name, type_sub_key: type_sub_key).to_list_type}, property: reflection.name.to_sym do
                                 if GraphqlModelMapper.use_authorize
                                     authorized ->(ctx, model_name, access_type) { GraphqlModelMapper.authorized?(ctx, model_name, access_type.to_sym) }
                                     model_name klass.name
@@ -148,163 +171,134 @@ module GraphqlModelMapper
                             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   
+                        if reflection.options[:polymorphic]
+                            # if a union type is defined in custom types use it, otherwise generate a union type from the association definition (requires a table scan)
+                            custom_type_name = "#{name.classify}#{reflection.name.to_s.classify}Union"
+                            if GraphqlModelMapper::CustomType.const_defined?(custom_type_name)
+                                field reflection.name.to_sym, -> {GraphqlModelMapper::CustomType.const_get(custom_type_name)}, property: reflection.name.to_sym 
+                            elsif GraphqlModelMapper.scan_for_polymorphic_associations   
+                                field reflection.name.to_sym, -> {GraphqlModelMapper::MapperType.get_polymorphic_type(reflection, name)}, property: reflection.name.to_sym    
+                            end 
+                        else
+                            field reflection.name.to_sym, -> {GraphqlModelMapper::MapperType.get_ar_object_with_params(klass.name, type_sub_key: type_sub_key)}, property: reflection.name.to_sym 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
                 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))}
+                # create GraphQL fields for each exposed database field
+                # get primary keys if requested
+                implements GraphQL::Relay::Node.interface
+                global_id_field :id    
+                db_fields.select{|s| (primary_keys && s.to_sym == :id)}.each do |f|
+                    field "item_id".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))}, property: :id do
+                    resolve -> (obj, args, ctx) {
+                        obj[:id]
+                    }
+                    end
+                end
+                # force required attributes to be non-null
+                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)}, property: f.to_sym
+                end       
+                # get the remaining fields and apply custom type if defined
+                db_fields.reject{|s| (s.to_sym == :id) || required_attributes.include?(s)}.sort.each do |f|
+                    custom_type_name = "#{name.classify}#{f.to_s.classify}AttributeOutput"
+                    if GraphqlModelMapper::CustomType.const_defined?(custom_type_name)
+                        field f.to_sym, GraphqlModelMapper::CustomType.const_get(custom_type_name), property: f.to_sym
+                    else
+                        if enums.include?(f.to_s)
+                            field f.to_sym, -> {GraphqlModelMapper::MapperType.get_enum_object(name, enum_values[f.to_s], f.to_s)}, property: f.to_sym
+                        else
+                            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))}, property: f.to_sym
+                        end
+                    end
                 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)
+
+        def self.get_polymorphic_type(reflection, model_name)
+            type_name = "#{model_name}#{reflection.name.to_s.classify}UnionOutput"
+
+            return GraphqlModelMapper.get_constant(type_name) if GraphqlModelMapper.defined_constant?(type_name)
+
+            model = model_name.classify.constantize
+            has_with_deleted = model.public_methods.include?(:with_deleted)
+            parent_name = "#{reflection.name}_type"
+            parent_classes = has_with_deleted ? model.with_deleted.select("distinct #{parent_name}").map{|m| m.send("#{parent_name}".to_sym)} :  model.select("distinct #{parent_name}").map{|m| m.send("#{parent_name}".to_sym)}
+            types = []
+            parent_classes.each do |p|
+                types << self.get_ar_object_with_params(p, type_sub_key: type_sub_key)
+            end
+
+            ret_type = GraphQL::UnionType.define do
+                name type_name
+                description "UnionType for polymorphic association #{reflection.name} on #{model_name}"
+                possible_types types
+                resolve_type ->(obj, ctx) {
+                    GraphqlModelMapper::MapperType.get_ar_object_with_params(obj.class.name)
+                }
+            end
+            GraphqlModelMapper.set_constant(type_name, ret_type)
+            GraphqlModelMapper.get_constant(type_name)
+        end
+
+        def self.get_type_params(name, type_sub_key: :output_type)
             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)
+            if !type_sub_key.nil?
+                if params.keys.include?(type_sub_key.to_sym)
                     params = params[type_sub_key.to_sym]
-                    else
+                else
                     params = nil
-                    end
                 end
-                else
+            else
                 params = nil
-                end
             end
+            params[:type_sub_key] = type_sub_key
             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") 
+                input_type: {
+                    required_attributes: [], 
+                    excluded_attributes: [], 
+                    allowed_attributes: [], 
+                    foreign_keys: true, 
+                    primary_keys: true, 
+                    validation_keys: false, 
+                    association_macro: nil, 
+                    source_nulls: false
+                },
+                output_type: {
+                    required_attributes: [], 
+                    excluded_attributes: [], 
+                    allowed_attributes: [], 
+                    foreign_keys: true, 
+                    primary_keys: true, 
+                    validation_keys: false, 
+                    association_macro: nil, 
+                    source_nulls: false
+                }
+            )
+            return GraphqlModelMapper::CustomType.const_get("GRAPHQL_DEFAULT_TYPES") if GraphqlModelMapper::CustomType.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[:input_type] = input_type
+            graphql_type[:output_type] = output_type
+            
+            GraphqlModelMapper::CustomType.const_set("GRAPHQL_DEFAULT_TYPES", graphql_type)
             graphql_type
         end
     
@@ -314,6 +308,20 @@ module GraphqlModelMapper
             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
 
+        def self.get_enum_object(model_name, enum, enum_name)
+            enum_values = enum.keys
+            type_name = "#{model_name.classify}#{enum_name.classify}Enum"
+            return GraphqlModelMapper.get_constant(type_name) if GraphqlModelMapper.defined_constant?(type_name)
+            ret_type = GraphQL::EnumType.define do
+                name type_name
+                description "generated GraphQL enum for ActiveRecord enum #{enum_name} on model #{model_name}"
+                enum_values.each do |v|
+                    value(v.classify, "", value: v)
+                end
+            end
+            GraphqlModelMapper.set_constant(type_name, ret_type)
+            GraphqlModelMapper.get_constant(type_name)
+        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