graphql_model_mapper 0.0.6 → 0.1.0

data/lib/graphql_model_mapper/mutation.rb

@@ -4,8 +4,8 @@ module GraphqlModelMapper
             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)
+            input_type = GraphqlModelMapper::MapperType.get_ar_object_with_params(name, type_sub_key: :input_type)
+            output_type = GraphqlModelMapper::MapperType.get_ar_object_with_params(name, type_sub_key: :output_type)
       
             self.get_mutation(name, description, "Update", resolver, input_type, output_type, name.downcase, "item")
           end
@@ -15,21 +15,22 @@ module GraphqlModelMapper
             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
+            input_type = GraphqlModelMapper::MapperType.get_ar_object_with_params(name, type_sub_key: :input_type)
+            output_type = GraphqlModelMapper::MapperType.get_ar_object_with_params(name, 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)
+            input_type = GraphqlModelMapper::MapperType.get_ar_object_with_params(name, type_sub_key: :input_type)
+            output_type = GraphqlModelMapper::MapperType.get_ar_object_with_params(name, 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)
+            model = name.classify.constantize
             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
@@ -38,7 +39,7 @@ module GraphqlModelMapper
               input_field input_name.to_sym, -> {input_type}
               return_field output_name.to_sym, -> {output_type}
         
-              resolve resolver
+              resolve GraphqlModelMapper::Mutation.get_resolver(resolver, model, operation_name.downcase.to_sym)
             end
         
             GraphqlModelMapper.set_constant(mutation_type_name, mutation_type.field)
@@ -50,33 +51,50 @@ module GraphqlModelMapper
             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")     
+            default_arguments = arguments ? (arguments.length > 0 ? 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)
+              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)
+              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] do                  
+                      if k[:authorization] && GraphqlModelMapper.use_authorize
+                        authorized ->(ctx, model_name, access_type) { GraphqlModelMapper.authorized?(ctx, model_name, access_type.to_sym) }
+                        model_name name
+                        access_type k[:authorization] 
+                      end       
+                    end 
+                  end
+              end
+              GraphqlModelMapper.set_constant(select_input_type_name, query_input_object_type)
             end
         
+            total_result_type_name = GraphqlModelMapper.get_type_case("TotalResult")                                         
+            if GraphqlModelMapper.defined_constant?(total_result_type_name)
+              total_result_type = GraphqlModelMapper.get_constant(total_result_type_name)
+            else
+              total_result_type =  GraphQL::InterfaceType.define do
+                name total_result_type_name
+                field :total, -> {GraphQL::INT_TYPE} do
+                  resolve -> (obj, args, ctx) {
+                    obj.items.length
+                  }
+                end
+              end
+              GraphqlModelMapper.set_constant(total_result_type_name, total_result_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}
+                return_interfaces [total_result_type]
                 input_field :select, -> {!query_input_object_type}
-        
-                resolve resolver 
+
+                resolve GraphqlModelMapper::Mutation.get_resolver(resolver, model, :delete) 
             end
             GraphqlModelMapper.set_constant(query_type_name, ret_type.field)
             GraphqlModelMapper.get_constant(query_type_name)
@@ -84,19 +102,25 @@ module GraphqlModelMapper
 
         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}
+              {:name=>:id,    :type=>GraphQL::ID_TYPE, :default=>nil}, 
+              {:name=>:ids,    :type=>GraphQL::ID_TYPE.to_list_type, :default=>nil},
             ]
+
+            default_arguments = default_arguments + [
+              {:name=>:item_id,    :type=>GraphQL::INT_TYPE, :default=>nil}, 
+              {:name=>:item_ids,    :type=>GraphQL::INT_TYPE.to_list_type, :default=>nil}
+            ] if GraphqlModelMapper::MapperType.get_type_params(model.name, type_sub_key: :input_type)[:primary_keys]
         
+            default_arguments = default_arguments + [
+              {:name=>:explain,   :type=>GraphQL::BOOLEAN_TYPE, :default=>nil, :authorization=>:manage}, 
+              {:name=>:order,   :type=>GraphQL::STRING_TYPE, :default=>nil, :authorization=>:manage}, 
+              {:name=>:where, :type=>GraphQL::STRING_TYPE.to_list_type, :default=>nil, :authorization=>:manage }
+            ]
+
             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}
+              default_arguments << {:name=>:with_deleted, :type=>GraphQL::BOOLEAN_TYPE, :default=>false, :authorization=>:manage}
             end
             allowed_scope_methods = []
             if scope_methods.count > 0
@@ -116,10 +140,29 @@ module GraphqlModelMapper
                   end
                   GraphqlModelMapper.set_constant typename, enum_type
                 end
-                default_arguments << {:name=>:scope, :type=>GraphqlModelMapper.get_constant(typename), :default=>nil}
+                default_arguments << {:name=>:scope, :type=>GraphqlModelMapper.get_constant(typename), :default=>nil, :authorization=>:manage}
               end
             end
             default_arguments
-        end          
+        end
+        
+        def self.get_resolver(resolver, model, operation)
+          if model.public_methods.include?("graphql_#{operation}_resolver".to_sym)
+            case operation
+              when :create
+                resolver = -> (obj, args, ctx) {model.graphql_create_resolver(obj,args,ctx) } if model.public_methods.include?(:graphql_create_resolver)
+              when :delete
+                resolver = -> (obj, args, ctx) {model.graphql_delete_resolver(obj,args,ctx) } if model.public_methods.include?(:graphql_delete_resolver)
+              when :update
+                resolver = -> (obj, args, ctx) {model.graphql_update_resolver(obj,args,ctx) } if model.public_methods.include?(:graphql_update_resolver)
+            end
+          end
+          if GraphqlModelMapper.mutation_resolve_wrapper && GraphqlModelMapper.mutation_resolve_wrapper < GraphqlModelMapper::Resolve::ResolveWrapper
+            return GraphqlModelMapper.mutation_resolve_wrapper.new(resolver)
+          else
+            return GraphqlModelMapper::Resolve::ResolveWrapper.new(resolver)
+          end
+        end
+           
     end
 end    

data/lib/graphql_model_mapper/query.rb

@@ -7,26 +7,39 @@ module GraphqlModelMapper
             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)
+            input_type = GraphqlModelMapper::MapperType.get_ar_object_with_params(name, type_sub_key: :input_type)
+            output_type = GraphqlModelMapper::MapperType.get_ar_object_with_params(name, 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}
+              {:name=>:id,    :type=>GraphQL::ID_TYPE, :default=>nil}, 
+              {:name=>:ids,    :type=>GraphQL::ID_TYPE.to_list_type, :default=>nil},
             ]
-        
+
+            default_arguments = default_arguments + [
+              {:name=>:item_id,    :type=>GraphQL::INT_TYPE, :default=>nil}, 
+              {:name=>:item_ids,    :type=>GraphQL::INT_TYPE.to_list_type, :default=>nil}
+            ] if GraphqlModelMapper::MapperType.get_type_params(model.name, type_sub_key: :input_type)[:primary_keys]
+
+
+            default_arguments = default_arguments + [
+              {:name=>:explain,   :type=>GraphQL::BOOLEAN_TYPE, :default=>nil, :authorization=>:manage}, 
+              {:name=>:order,   :type=>GraphQL::STRING_TYPE, :default=>nil, :authorization=>:manage}, 
+              {:name=>:where, :type=>GraphQL::STRING_TYPE.to_list_type, :default=>nil, :authorization=>:manage }
+            ]
+=begin            
+            default_arguments = default_arguments + [
+#              {:name=>:limit, :type=>GraphQL::INT_TYPE, :default=>GraphqlModelMapper.max_page_size}, 
+              {:name=>:first, :type=>GraphQL::INT_TYPE, :default=>nil}, 
+              {:name=>:last, :type=>GraphQL::INT_TYPE, :default=>nil}, 
+              {:name=>:offset, :type=>GraphQL::INT_TYPE, :default=>nil}] if ![:deep, :shallow].include?(GraphqlModelMapper.nesting_strategy)
+=end        
             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}
+              default_arguments << {:name=>:with_deleted, :type=>GraphQL::BOOLEAN_TYPE, :default=>false, :authorization=>:manage}
             end
             allowed_scope_methods = []
             if scope_methods.count > 0
@@ -46,7 +59,7 @@ module GraphqlModelMapper
                   end
                   GraphqlModelMapper.set_constant typename, enum_type
                 end
-                default_arguments << {:name=>:scope, :type=>GraphqlModelMapper.get_constant(typename), :default=>nil}
+                default_arguments << {:name=>:scope, :type=>GraphqlModelMapper.get_constant(typename), :default=>nil, :authorization=>:manage}
               end
             end
             default_arguments
@@ -59,8 +72,12 @@ module GraphqlModelMapper
             
             model = name.classify.constantize
         
-            default_arguments = self.get_default_select_arguments(model, scope_methods)
+            default_arguments = arguments ? (arguments.length > 0 ? arguments : self.get_default_select_arguments(model, scope_methods)) : []
+
+
+=begin
             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
@@ -72,7 +89,43 @@ module GraphqlModelMapper
               end
               GraphqlModelMapper.set_constant(select_input_type_name, select_input_type)
             end
-        
+=end
+=begin
+            page_info_type_name = "FlatPageInfo"     
+
+            if GraphqlModelMapper.defined_constant?(page_info_type_name)
+              page_info_type = GraphqlModelMapper.get_constant(page_info_type_name)
+            else
+              page_info_type = GraphQL::ObjectType.define do
+                name("FlatPageInfo")
+                description("Information about pagination in a query.")
+                field :hasNextPage, !types.Boolean, "When paginating forwards, are there more items?", property: :has_next_page
+                field :hasPreviousPage, !types.Boolean, "When paginating backwards, are there more items?", property: :has_previous_page
+                field :startCursor, types.String, "When paginating backwards, the cursor to continue.", property: :start_cursor
+                field :endCursor, types.String, "When paginating forwards, the cursor to continue.", property: :end_cursor
+              end
+              GraphqlModelMapper.set_constant(page_info_type_name, page_info_type)
+            end
+=end           
+
+            if [:deep, :shallow].include?(GraphqlModelMapper.nesting_strategy)
+                connection_type_name = "#{GraphqlModelMapper.get_type_case(GraphqlModelMapper.get_type_name(name))}ConnectionType"
+                if GraphqlModelMapper.defined_constant?(connection_type_name)
+                    connection_type = GraphqlModelMapper.get_constant(connection_type_name)
+                else
+                    connection_type = output_type.define_connection do
+                        name connection_type_name
+                        field :total, hash_key: :total do
+                            type types.Int
+                            resolve ->(obj, args, ctx) {
+                                obj.nodes.count 
+                            }
+                        end
+                    end
+                    GraphqlModelMapper.set_constant(connection_type_name, connection_type)
+                end
+            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)
@@ -80,11 +133,46 @@ module GraphqlModelMapper
               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
+                  connection :items, -> {connection_type}, max_page_size: GraphqlModelMapper.max_page_size do 
+                        resolve -> (obj, args, ctx) {
+                            limit = GraphqlModelMapper.max_page_size
+                            raise GraphQL::ExecutionError.new("you have exceeded the maximum requested page size #{limit}") if args[:first].to_i > limit || args[:last].to_i > limit
+
+                            obj
+                        }
+                    end
                 else
-                  field :items, -> {output_type.to_list_type}, hash_key: :items
+                  field :items, -> {output_type.to_list_type}, hash_key: :items do
+                    argument :per_page, GraphQL::INT_TYPE
+                    argument :page, GraphQL::INT_TYPE
+                    resolve->(obj, args, ctx){
+                      first_rec = nil
+                      last_rec = nil
+                      limit = GraphqlModelMapper.max_page_size.to_i
+                      
+                      if args[:per_page]
+                        per_page = args[:per_page].to_i
+                        raise GraphQL::ExecutionError.new("per_page must be greater than 0") if per_page < 1
+                        raise GraphQL::ExecutionError.new("you have exceeded the maximum requested page size #{limit}") if per_page > limit
+                        limit = [per_page,limit].min
+                      end
+                      if args[:page]
+                        page = args[:page].to_i
+                        raise GraphQL::ExecutionError.new("page must be greater than 0") if page < 1
+                        max_page = (obj.count/per_page).floor + 1
+                        raise GraphQL::ExecutionError.new("you requested page #{page} which is greater than the max number of pages #{max_page}") if page > max_page
+                        obj = obj.offset((page-1)*limit)
+                      end
+                      obj = obj.limit(limit)
+                      obj
+                    }
+                  end
+                  field :total, -> {GraphQL::INT_TYPE}, hash_key: :total do 
+                    resolve->(obj,args, ctx){
+                        obj.limit(nil).count
+                    }
+                  end
                 end
-                field :total, -> {GraphQL::INT_TYPE}, hash_key: :total
               end
               GraphqlModelMapper.set_constant(total_output_type_name, total_output_type)
             end
@@ -93,15 +181,31 @@ module GraphqlModelMapper
             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] 
+                  argument k[:name].to_sym, k[:type], k[:description], default_value: k[:default] do                  
+                    if k[:authorization] && GraphqlModelMapper.use_authorize
+                      authorized ->(ctx, model_name, access_type) { GraphqlModelMapper.authorized?(ctx, model_name, access_type.to_sym) }
+                      model_name name
+                      access_type k[:authorization] 
+                    end       
+                  end
                 end
-        
-                resolve resolver 
-              end
+                resolve GraphqlModelMapper::Query.get_resolver(resolver, model)
+            end
             GraphqlModelMapper.set_constant(query_type_name, ret_type)
             GraphqlModelMapper.get_constant(query_type_name)
         end
+
+
+        def self.get_resolver(resolver, model)
+          
+          resolver = -> (obj,args,ctx){ model.graphql_query_resolver(obj, args, ctx) } if model.public_methods.include?(:graphql_query_resolver)
+
+          if GraphqlModelMapper.query_resolve_wrapper && GraphqlModelMapper.query_resolve_wrapper < GraphqlModelMapper::Resolve::ResolveWrapper
+            return GraphqlModelMapper.query_resolve_wrapper.new(resolver)
+          else
+            return GraphqlModelMapper::Resolve::ResolveWrapper.new(resolver)
+          end
+        end
     end
 end    

data/lib/graphql_model_mapper/resolve.rb

@@ -1,239 +1,285 @@
 module GraphqlModelMapper
-    module Resolve
-        def self.query_resolver(obj, args, ctx, name)
-            obj_context = name.classify.constantize
-            select_args = args[:select] || args
-        
-            if !GraphqlModelMapper.authorized?(ctx, obj_context.name, :query)
-              raise GraphQL::ExecutionError.new("error: unauthorized access: #{:query} '#{obj_context.class_name.classify}'")
-            end
-            classmethods = []
-            scope_allowed = false
-            with_deleted_allowed = false
-            if select_args[:scope]
-              classmethods = obj_context.methods - Object.methods
-              scope_allowed = classmethods.include?(select_args[:scope].to_sym)
-              raise GraphQL::ExecutionError.new("error: invalid scope '#{select_args[:scope]}' specified, '#{select_args[:scope]}' method does not exist on '#{ctx.field.name.classify}'") unless scope_allowed
-            end
-            if select_args[:with_deleted]
-              classmethods = obj_context.methods - Object.methods
-              with_deleted_allowed = classmethods.include?(:with_deleted)
-              raise GraphQL::ExecutionError.new("error: invalid usage of 'with_deleted', 'with_deleted' method does not exist on '#{ctx.field.name.classify}'") unless with_deleted_allowed
-            end
-
-            implied_includes = self.get_implied_includes(name.classify.constantize, ctx.ast_node)
+  module Resolve
+    def self.query_resolver(obj, args, ctx, name)
+        #binding.pry
+        obj_context = obj || name.classify.constantize
+        select_args = args[:select] || args
+    
+        if !GraphqlModelMapper.authorized?(ctx, obj_context.name, :query)
+          raise GraphQL::ExecutionError.new("error: unauthorized access: #{:query} '#{obj_context.class_name.classify}'")
+        end
+        classmethods = []
+        scope_allowed = false
+        with_deleted_allowed = false
+        if select_args[:scope]
+          classmethods = obj_context.methods - Object.methods
+          scope_allowed = classmethods.include?(select_args[:scope].to_sym)
+          raise GraphQL::ExecutionError.new("error: invalid scope '#{select_args[:scope]}' specified, '#{select_args[:scope]}' method does not exist on '#{obj_context.class_name.classify}'") unless scope_allowed
+        end
+        if select_args[:with_deleted]
+          classmethods = obj_context.methods - Object.methods
+          with_deleted_allowed = classmethods.include?(:with_deleted)
+          raise GraphQL::ExecutionError.new("error: invalid usage of 'with_deleted', 'with_deleted' method does not exist on '#{obj_context.class_name.classify}'") unless with_deleted_allowed
+        end
 
-            if !implied_includes.empty? 
-              obj_context = obj_context.includes(implied_includes)
-              if Rails.version.split(".").first.to_i > 3
-                obj_context = obj_context.references(implied_includes)
-              end
-            end
-            if select_args[:ids]
-                obj_context = obj_context.where(["#{obj_context.model_name.plural}.id in (?)", select_args[:ids]])
-            end
-            if select_args[:id]
-              obj_context = obj_context.where(["#{obj_context.model_name.plural}.id = ?", select_args[:id].to_i])
-            end
-            if select_args[:where]
-              obj_context = obj_context.where(select_args[:where])
-            end
-            if with_deleted_allowed
-              obj_context = obj_context.with_deleted
-            end
-            if scope_allowed
-              obj_context = obj_context.send(select_args[:scope].to_sym)
-            end
-            if !select_args[:limit].nil? && select_args[:limit].to_f > 0
-              obj_context = obj_context.limit(select_args[:limit])
-            end
-            if select_args[:offset]
-              obj_context = obj_context.offset(select_args[:offset])
-            end
-            if select_args[:order]
-              obj_context = obj_context.order(select_args[:order])
-            end
-            if select_args[:explain]
-              obj_context = obj_context.eager_load(implied_includes)
-              raise GraphQL::ExecutionError.new(obj_context.explain.split("\n").first.sub("EXPLAIN for: ", ""))
-            end
-            obj_context
+        implied_includes = self.get_implied_includes(obj_context.name.classify.constantize, ctx.ast_node)
+        if !implied_includes.empty? 
+          obj_context = obj_context.includes(implied_includes)
+          if Rails.version.split(".").first.to_i > 3
+            obj_context = obj_context.references(implied_includes)
+          end
         end
+        if select_args[:id]
 
-        def self.update_resolver(obj, inputs, ctx, name)
-            item = GraphqlModelMapper::Resolve.nested_update(ctx, name, inputs)
-            item
+          type_name, item_id = GraphQL::Schema::UniqueWithinType.decode(select_args[:id])
+          raise GraphQL::ExecutionError.new("incorrect global id: unable to resolve type for id:'#{select_args[:id]}'") if type_name.nil?
+          model_name = GraphqlModelMapper.get_constant(type_name.upcase).metadata[:model_name].to_s.classify
+          raise GraphQL::ExecutionError.new("incorrect global id '#{select_args[:id]}': expected global id for '#{name}', received global id for '#{model_name}'") if model_name != name 
+          obj_context = obj_context.where(["#{obj_context.model_name.plural}.id = ?", item_id.to_i])
         end
-        
-        def self.delete_resolver(obj, inputs, ctx, model_name)
-            model = model_name.classify.constantize
-            items = self.query_resolver(obj, inputs, ctx, model_name)
-            ids = items.collect(&:id)
-            if !GraphqlModelMapper.authorized?(ctx, model_name, :update)
-                raise GraphQL::ExecutionError.new("error: unauthorized access: delete '#{model_name.classify}', transaction cancelled")
-            end    
-            begin
-                deleted_items = model.delete(ids)
-            rescue => e
-                raise e #GraphQL::ExecutionError.new("error: delete")
+        if select_args[:ids]
+          finder_array = []
+          errors = []
+          select_args[:ids].each do |id|
+            type_name, item_id = GraphQL::Schema::UniqueWithinType.decode(id)
+            if type_name.nil?
+              errors << "incorrect global id: unable to resolve type for id:'#{id}'"
+              next
             end
-            if model.methods.include?(:with_deleted)
-                items.with_deleted
-            else
-                items
+            model_name = GraphqlModelMapper.get_constant(type_name.upcase).metadata[:model_name].to_s.classify
+            if model_name != name 
+              errors << "incorrect global id '#{id}': expected global id for '#{name}', received global id for '#{model_name}'"
+              next
             end
+            finder_array << item_id.to_i
+          end
+          if errors.length > 0
+            raise GraphQL::ExecutionError.new(errors.join(";")) 
+          end
+          obj_context = obj_context.where(["`#{obj_context.model_name.plural}`.id in (?)", finder_array])
+        end
+        if select_args[:item_ids]
+          obj_context = obj_context.where(["`#{obj_context.model_name.plural}`.id in (?)", select_args[:item_ids]])
+        end
+        if select_args[:item_id]
+          obj_context = obj_context.where(["`#{obj_context.model_name.plural}`.id = ?", select_args[:item_id].to_i])
+        end
+        if select_args[:where]
+          obj_context = obj_context.where(select_args[:where])
+        end
+        if with_deleted_allowed
+          obj_context = obj_context.with_deleted
+        end
+        if scope_allowed
+          obj_context = obj_context.send(select_args[:scope].to_sym)
         end
+        if select_args[:order]
+          obj_context = obj_context.order(select_args[:order])
+        end
+        if select_args[:explain]
+          obj_context = obj_context.limit(1)
+          obj_context = obj_context.eager_load(implied_includes)
+          raise GraphQL::ExecutionError.new(obj_context.explain.split("\n").first.sub("EXPLAIN for: ", "").sub(" LIMIT 1", !select_args[:limit].nil? && select_args[:limit].to_f > 0 ? "LIMIT #{select_args[:limit]}" : ""))
+        end
+        #if select_args[:limit].nil?
+        #    obj_context = obj_context.limit(100)
+        #end
+        obj_context = obj_context.where("1=1")
+        obj_context
+    end
 
-        def self.create_resolver(obj, inputs, ctx, model_name)
-            if !GraphqlModelMapper.authorized?(ctx, model_name, :create)
-                raise GraphQL::ExecutionError.new("error: unauthorized access: create '#{model_name.classify}'")
-            end
-            model = model_name.classify.constantize   
-            item = model.new(inputs[model_name.downcase].to_h)
-            begin
-              if !item.valid?
-                raise GraphQL::ExecutionError.new(item.errors.full_messages.join("; "))
-              else
-                raise GraphQL::ExecutionError.new("error: WIP, item not saved but is a valid '#{model_name.classify}'")
-                #item.save!
-              end
-            end
-            item
+    def self.update_resolver(obj, inputs, ctx, name)
+        item = GraphqlModelMapper::Resolve.nested_update(ctx, name, inputs)
+        item
+    end
+    
+    def self.delete_resolver(obj, inputs, ctx, model_name)
+        model = model_name.classify.constantize
+        items = self.query_resolver(obj, inputs, ctx, model_name)
+        ids = items.collect(&:id)
+        if !GraphqlModelMapper.authorized?(ctx, model_name, :update)
+            raise GraphQL::ExecutionError.new("error: unauthorized access: delete '#{model_name.classify}', transaction cancelled")
+        end    
+        begin
+            deleted_items = model.delete(ids)
+        rescue => e
+            raise e #GraphQL::ExecutionError.new("error: delete")
+        end
+        if model.methods.include?(:with_deleted)
+            items.with_deleted
+        else
+            items
         end
+    end
 
-          def self.using_relay_pagination?(selection)
-          selection.name == 'edges'
+    def self.create_resolver(obj, inputs, ctx, model_name)
+        if !GraphqlModelMapper.authorized?(ctx, model_name, :create)
+            raise GraphQL::ExecutionError.new("error: unauthorized access: create '#{model_name.classify}'")
         end
-    
-        def self.using_is_items_collection?(selection)
-          selection.name == 'items'
+        model = model_name.classify.constantize   
+        item = model.new(inputs[model_name.downcase].to_h)
+        begin
+          if !item.valid?
+            raise GraphQL::ExecutionError.new(item.errors.full_messages.join("; "))
+          else
+            raise GraphQL::ExecutionError.new("error: WIP, item not saved but is a valid '#{model_name.classify}'")
+            #item.save!
+          end
         end
+        item
+    end
+
+      def self.using_relay_pagination?(selection)
+      selection.name == 'edges'
+    end
+
+    def self.using_is_items_collection?(selection)
+      selection.name == 'items'
+    end
+
+    def self.using_nodes_pagination?(selection)
+      selection.name == 'nodes'
+    end
+
+    def self.has_reflection_with_name?(class_name, selection_name)
+      class_name.reflect_on_all_associations.select{|m|m.name == selection_name.to_sym}.present?
+    end
+
+    def self.map_relay_pagination_depencies(class_name, selection, dependencies)
+      node_selection = selection.selections.find { |sel| sel.name == 'node' }
+
+      if node_selection.present?
+        get_implied_includes(class_name, node_selection, dependencies)
+      else
+        dependencies
+      end
+    end
+
+    def self.get_implied_includes(class_name, ast_node, dependencies={})
+      ast_node.selections.each do |selection|
+        name = selection.name
 
-        def self.using_nodes_pagination?(selection)
-          selection.name == 'nodes'
+        if using_relay_pagination?(selection)
+          map_relay_pagination_depencies(class_name, selection, dependencies)
+          next
         end
 
-        def self.has_reflection_with_name?(class_name, selection_name)
-          class_name.reflect_on_all_associations.select{|m|m.name == selection_name.to_sym}.present?
+        if using_nodes_pagination?(selection)
+          get_implied_includes(class_name, selection, dependencies)
+          next
         end
 
-        def self.map_relay_pagination_depencies(class_name, selection, dependencies)
-          node_selection = selection.selections.find { |sel| sel.name == 'node' }
-    
-          if node_selection.present?
-            get_implied_includes(class_name, node_selection, dependencies)
-          else
-            dependencies
-          end
+        if using_is_items_collection?(selection)
+          get_implied_includes(class_name, selection, dependencies)
+          next
         end
 
-        def self.get_implied_includes(class_name, ast_node, dependencies={})
-          ast_node.selections.each do |selection|
-            name = selection.name
-    
-            if using_relay_pagination?(selection)
-              map_relay_pagination_depencies(class_name, selection, dependencies)
-              next
-            end
-    
-            if using_nodes_pagination?(selection)
-              get_implied_includes(class_name, selection, dependencies)
-              next
+        if has_reflection_with_name?(class_name, name)
+          begin
+            current_class_name = selection.name.singularize.classify.constantize
+            dependencies[name] = get_implied_includes(current_class_name, selection)
+          rescue NameError
+            selection_name = class_name.reflections.with_indifferent_access[selection.name].class_name
+            begin                  
+              current_class_name = selection_name.singularize.classify.constantize
+              dependencies[selection.name.to_sym] = get_implied_includes(current_class_name, selection)
+            rescue
+                # this will occur if the relation is polymorphic, since polymorphic associations do not have a class_name
+                GraphqlModelMapper.logger.info "implied_includes: #{class_name} could not resolve a class for relation #{selection.name}"
             end
+            next
+          end
+        end
+      end
+      dependencies
+    end
 
-            if using_is_items_collection?(selection)
-              get_implied_includes(class_name, selection, dependencies)
-              next
-            end
-    
-            if has_reflection_with_name?(class_name, name)
-              begin
-                current_class_name = selection.name.singularize.classify.constantize
-                dependencies[name] = get_implied_includes(current_class_name, selection)
-              rescue NameError
-                selection_name = class_name.reflections.with_indifferent_access[selection.name].options[:class_name]
-                current_class_name = selection_name.singularize.classify.constantize
-                dependencies[selection.name.to_sym] = get_implied_includes(current_class_name, selection)
-                next
-              end
+
+    def self.nested_update(ctx, model_name, inputs, child_name=nil, child_id=nil, parent_name=nil, parent_id=nil, klass_name=nil)
+      model = model_name.classify.constantize
+      
+      if !child_name.nil? && !child_id.nil? # has_many && has_one
+        inputs_root = inputs
+        #puts "inputs_root[:item_id] #{inputs_root[:item_id]} #{inputs_root}"
+        if model.public_methods.include?(:with_deleted)
+          item = model.with_deleted.where("id = ? and #{child_name.downcase}_id = ?", inputs_root[:item_id], child_id).first
+        else
+          item = model.where("id = ? and #{child_name.downcase}_id = ?", inputs_root[:item_id], child_id).first
+        end
+        raise GraphQL::ExecutionError.new("error: #{model.name} record not found for #{model.name}.id = #{inputs_root[:item_id]} and #{model.name}.#{child_name.downcase}_id = #{child_id}") if item.nil?
+      elsif !parent_name.nil? && !parent_id.nil? # belongs_to
+        inputs_root = inputs
+        #puts "parent_id #{parent_id} parent_name #{parent_name} #{model_name} model.with_deleted.find(#{parent_id}).send(#{parent_name}.to_sym).id} inputs_root[:item_id] #{inputs_root[:item_id]} #{inputs_root}"
+        if model.public_methods.include?(:with_deleted)
+          item = model.with_deleted.find(parent_id).public_send(parent_name.to_sym) if model.with_deleted.find(parent_id).public_send(parent_name.to_sym) && model.with_deleted.find(parent_id).public_send(parent_name.to_sym).id == inputs_root[:item_id]
+        else
+          item = model.find(parent_id).public_send(parent_name.to_sym) if model.find(parent_id).public_send(parent_name.to_sym) && model.with_deleted.find(parent_id).public_send(parent_name.to_sym).id == inputs_root[:item_id]
+        end
+        raise GraphQL::ExecutionError.new("error: #{model.name}.#{parent_name} record not found for  #{model.name}.with_deleted.find(#{parent_id}).#{parent_name}_id = #{inputs_root[:item_id]}") if item.nil?
+        model_name = klass_name
+        model = klass_name.classify.constantize
+      else #root query always single record, need to offeset property for object_input_type
+        inputs_root = inputs[model_name.downcase]
+        #puts "inputs_root[:item_id] #{inputs_root[:item_id]} #{inputs_root}"
+        if model.public_methods.include?(:with_deleted)
+          item = model.with_deleted.find(inputs_root[:item_id])
+        else
+          item = model.find(inputs_root[:item_id])
+        end
+        raise GraphQL::ExecutionError.new("error: #{model.name} record not found for #{model.name}.id=#{inputs[model_name.downcase][:item_id]}") if item.nil?
+      end
+      if !GraphqlModelMapper.authorized?(ctx, model.name, :update)
+        raise GraphQL::ExecutionError.new("error: unauthorized access: #{:update} '#{model}', transaction cancelled")
+      end
+  
+      item_associations = model.reflect_on_all_associations.select{|t| begin t.klass rescue next end}.select{|t| !t.options[:polymorphic]}
+      item_association_names = item_associations.map{|m| m.name.to_s}
+      input_association_names = item_association_names & inputs_root.to_h.keys
+      
+      item.transaction do
+        #puts "***********item.update_attributes(#{inputs_root.to_h.except('id').except!(*item_association_names)})"
+        #puts "***********ctx[current_user.to_sym].is_admin?(#{ctx[:current_user].is_admin?})"
+        item.update_attributes(inputs_root.to_h.except('id').except('item_id').except!(*item_association_names))
+        input_association_names.each do |ia|
+          lclinput = inputs_root[ia]
+          ass = item_associations.select{|a| a.name.to_s == ia}.first
+          klass = ass.klass
+          is_collection = ass.collection?
+          belongs_to = ass.belongs_to?
+          #puts "#{ass.name} #{ass.collection?} #{ass.belongs_to?}"
+          #puts "#{ass.association_foreign_key} #{ass.association_primary_key} #{ass.active_record_primary_key}"
+          
+          if is_collection
+            #puts "is_collection"
+            lclinput.each do |i|
+              #puts "#{klass.name}  #{i.to_h}  #{model_name.downcase} #{inputs_root[:item_id]}"
+              GraphqlModelMapper::Resolve.nested_update(ctx, klass.name, i, model_name.downcase, inputs_root[:item_id])
             end
+          elsif !is_collection && belongs_to
+            #puts "belongs_to"
+            #puts "self.nested_update(#{ctx}, #{model.name}, #{lclinput.to_h}, nil, nil, #{ass.name}, #{inputs_root[:item_id]}, #{klass.name})"
+            GraphqlModelMapper::Resolve.nested_update(ctx, model.name, lclinput, nil, nil, ass.name, inputs_root[:item_id], klass.name)
+          elsif !is_collection && !belongs_to #has_one
+            #puts "has_one"
+            #puts "self.nested_update(#{ctx}, #{klass.name}, #{lclinput.to_h}, #{model_name.downcase}, #{inputs_root[:item_id]})"
+            GraphqlModelMapper::Resolve.nested_update(ctx, model.name, lclinput, nil, nil, ass.name, inputs_root[:item_id], klass.name)
           end
-          dependencies
         end
+      end
+      item
+    end
     
-
-        def self.nested_update(ctx, model_name, inputs, child_name=nil, child_id=nil, parent_name=nil, parent_id=nil, klass_name=nil)
-            model = model_name.classify.constantize
-            
-            if !child_name.nil? && !child_id.nil? # has_many && has_one
-              inputs_root = inputs
-              #puts "inputs_root[:id] #{inputs_root[:id]} #{inputs_root}"
-              if model.public_methods.include?(:with_deleted)
-                item = model.with_deleted.where("id = ? and #{child_name.downcase}_id = ?", inputs_root[:id], child_id).first
-              else
-                item = model.where("id = ? and #{child_name.downcase}_id = ?", inputs_root[:id], child_id).first
-              end
-              raise GraphQL::ExecutionError.new("error: #{model.name} record not found for #{model.name}.id = #{inputs_root[:id]} and #{model.name}.#{child_name.downcase}_id = #{child_id}") if item.nil?
-            elsif !parent_name.nil? && !parent_id.nil? # belongs_to
-              inputs_root = inputs
-              #puts "parent_id #{parent_id} parent_name #{parent_name} #{model_name} model.with_deleted.find(#{parent_id}).send(#{parent_name}.to_sym).id} inputs_root[:id] #{inputs_root[:id]} #{inputs_root}"
-              if model.public_methods.include?(:with_deleted)
-                item = model.with_deleted.find(parent_id).public_send(parent_name.to_sym) if model.with_deleted.find(parent_id).public_send(parent_name.to_sym) && model.with_deleted.find(parent_id).public_send(parent_name.to_sym).id == inputs_root[:id]
-              else
-                item = model.find(parent_id).public_send(parent_name.to_sym) if model.find(parent_id).public_send(parent_name.to_sym) && model.with_deleted.find(parent_id).public_send(parent_name.to_sym).id == inputs_root[:id]
-              end
-              raise GraphQL::ExecutionError.new("error: #{model.name}.#{parent_name} record not found for  #{model.name}.with_deleted.find(#{parent_id}).#{parent_name}_id = #{inputs_root[:id]}") if item.nil?
-              model_name = klass_name
-              model = klass_name.classify.constantize
-            else #root query always single record, need to offeset property for object_input_type
-              inputs_root = inputs[model_name.downcase]
-              #puts "inputs_root[:id] #{inputs_root[:id]} #{inputs_root}"
-              if model.public_methods.include?(:with_deleted)
-                item = model.with_deleted.find(inputs_root[:id])
-              else
-                item = model.find(inputs_root[:id])
-              end
-              raise GraphQL::ExecutionError.new("error: #{model.name} record not found for #{model.name}.id=#{inputs[model_name.downcase][:id]}") if item.nil?
-            end
-            if !GraphqlModelMapper.authorized?(ctx, model.name, :update)
-              raise GraphQL::ExecutionError.new("error: unauthorized access: #{:update} '#{model}', transaction cancelled")
-            end
+    class ResolveWrapper
+      def initialize(resolve_func)
+        @resolve_func = resolve_func
+      end
+    
+      def call(obj, args, ctx)
+        begin
+          @resolve_func.call(obj, args, ctx)
         
-            item_associations = model.reflect_on_all_associations.select{|t| begin t.klass rescue next end}.select{|t| !t.options[:polymorphic]}
-            item_association_names = item_associations.map{|m| m.name.to_s}
-            input_association_names = item_association_names & inputs_root.to_h.keys
-            
-            item.transaction do
-              #puts "***********item.update_attributes(#{inputs_root.to_h.except('id').except!(*item_association_names)})"
-              #puts "***********ctx[current_user.to_sym].is_admin?(#{ctx[:current_user].is_admin?})"
-              item.update_attributes(inputs_root.to_h.except('id').except!(*item_association_names))
-              input_association_names.each do |ia|
-                lclinput = inputs_root[ia]
-                ass = item_associations.select{|a| a.name.to_s == ia}.first
-                klass = ass.klass
-                is_collection = ass.collection?
-                belongs_to = ass.belongs_to?
-                #puts "#{ass.name} #{ass.collection?} #{ass.belongs_to?}"
-                #puts "#{ass.association_foreign_key} #{ass.association_primary_key} #{ass.active_record_primary_key}"
-                
-                if is_collection
-                  #puts "is_collection"
-                  lclinput.each do |i|
-                    #puts "#{klass.name}  #{i.to_h}  #{model_name.downcase} #{inputs_root[:id]}"
-                    GraphqlModelMapper::Resolve.nested_update(ctx, klass.name, i, model_name.downcase, inputs_root[:id])
-                  end
-                elsif !is_collection && belongs_to
-                  #puts "belongs_to"
-                  #puts "self.nested_update(#{ctx}, #{model.name}, #{lclinput.to_h}, nil, nil, #{ass.name}, #{inputs_root[:id]}, #{klass.name})"
-                  GraphqlModelMapper::Resolve.nested_update(ctx, model.name, lclinput, nil, nil, ass.name, inputs_root[:id], klass.name)
-                elsif !is_collection && !belongs_to #has_one
-                  #puts "has_one"
-                  #puts "self.nested_update(#{ctx}, #{klass.name}, #{lclinput.to_h}, #{model_name.downcase}, #{inputs_root[:id]})"
-                  GraphqlModelMapper::Resolve.nested_update(ctx, model.name, lclinput, nil, nil, ass.name, inputs_root[:id], klass.name)
-                end
-              end
-            end
-            item
-          end                
+       end
+      end
     end
+  end
 end