graphql_model_mapper 0.1.0 → 0.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: edf76e62fad8e31f3b2e1572544f170a5c151051
-  data.tar.gz: dee948ab9a1125e55e19b588d5ef4837dd576ea4
+  metadata.gz: 6cca41868fb3cd1793a2d0fc46d26a09ff391a26
+  data.tar.gz: 133c44e736acb0fb3ae1e0a336c7f76f47016d2b
 SHA512:
-  metadata.gz: 5c930baf5c2c607361e43c43d377321a9f06278c927b3b8a486a2e3c8eb99c9c94dff808c00df050573979c2ac9aef7c07ac7549ab0496b32262ac4b3ada1052
-  data.tar.gz: 8cd16e8b313baab6b7608a6e39b6f8dbb2edd04b3f5bf9c9ec90f6bb2890756935b66e2d8f5ef3e5c338262d5de38bf072ee47324a79993650778527134ff109
+  metadata.gz: f695954eb400f758c0f31a48c76270b853357cc1e31cca9887a59e4cd06c23769167a9a16732b2f42f3c6fd4ca6bdfb198bda757cb2acf2e01a6bdb8b50bd5b4
+  data.tar.gz: 3caf36685531ae7a340438c2ef08840860cc200e0a200843725f8b638cb56d864ef24a271d4e4d39fb997dc4b1ce39b2d48b2786efe9a2d712a86b893a83d962

data/Gemfile

@@ -6,6 +6,7 @@ gem 'activerecord', '~>3.2.22.5', :require => 'active_record'
 gem 'activemodel', '~>3.2.22.5', :require => 'active_model'
 gem 'activesupport', '~>3.2.22.5', :require => 'active_support'
 gem 'graphql', '~>1.7.5'
+gem 'graphql-errors', '~>0.1.0'
 git_source(:github) {|repo_name| "https://github.com/#{repo_name}" }
 
 # Specify your gem's dependencies in graphql_model_mapper.gemspec

data/Gemfile.lock

@@ -1,11 +1,12 @@
 PATH
   remote: .
   specs:
-    graphql_model_mapper (0.1.0)
+    graphql_model_mapper (0.1.1)
       activemodel (>= 3.2.22.5)
       activerecord (>= 3.2.22.5)
       activesupport (>= 3.2.22.5)
       graphql (>= 1.7.5)
+      graphql-errors (>= 0.1.0)
       rails (>= 3.2.22.5)
 
 GEM
@@ -43,6 +44,8 @@ GEM
     concurrent-ruby (1.0.5)
     erubis (2.7.0)
     graphql (1.7.5)
+    graphql-errors (0.1.0)
+      graphql (>= 1.6.0, < 2)
     hike (1.2.3)
     i18n (0.9.1)
       concurrent-ruby (~> 1.0)
@@ -101,6 +104,7 @@ DEPENDENCIES
   activesupport (~> 3.2.22.5)
   bundler (~> 1.16)
   graphql (~> 1.7.5)
+  graphql-errors (~> 0.1.0)
   graphql_model_mapper!
   minitest (~> 5.0)
   rails (~> 3.2.22.5)

data/README.md

@@ -44,9 +44,7 @@ The default input/output types generated for the model are based on the default
             primary_keys: true, 
             validation_keys: false, 
             association_macro: nil, 
-            source_nulls: false,
-            type_key: :query,
-            type_sub_key: :input_type
+            source_nulls: false
         },
         output_type: {
             required_attributes: [], 
@@ -56,9 +54,7 @@ The default input/output types generated for the model are based on the default
             primary_keys: true, 
             validation_keys: false, 
             association_macro: nil, 
-            source_nulls: false,
-            type_key: :query,
-            type_sub_key: :output_type
+            source_nulls: false
         }
     }
 
@@ -188,13 +184,14 @@ Some other attributes that you can set on the macro functions in addition to the
 ## graphql_query
 
     description:    # a short description of the query
-    scope_methods:  # scope methods available to be used in the query, these should not be parameterized and must be written so that they valid in the presence of other tables which may be included in the associations
-    arguments:      # a list of argument definitions to override the default arguments, if using your own arguments you will need to override the query resolver to act on those arguments, the default 
+    scope_methods:  # scope methods available to be used in the query, these can be parameterized (must not be named parameters, must be accepted as string arguments and coerced in the method if needed) and must be written so that they valid in the presence of other tables which may be included in the associations
+    arguments:      # a list of argument definitions to override the default GraphQL arguments, if using your own arguments you will need to override the query resolver to act on those arguments 
     
-Arguments should be a list of objects with the following attirbutes (*required)
+Arguments should be a list of objects with the following attributes (*required)
+
     *name - displayed name of the attribute
     *type - GraphQL type of the attribute
-    default - default value
+    default - default argument value
     authorization - authorization level for the attribute (if GraphqlModelMapper.use_authorize = true this authorization will be compared to the authorized ability for the user on the model to which this attribute applies)
 
 The default arguments handled by the default resolver and exposed on the query and delete mutations are:
@@ -209,6 +206,7 @@ The default arguments handled by the default resolver and exposed on the query a
     {:name=>:offset,    :type=>GraphQL::INT_TYPE, :default=>nil},                                           # specifies an offset for the start of the records returned
     {:name=>:order,     :type=>GraphQL::STRING_TYPE, :default=>nil, :authorization=>:manage},               # a string value that is passed to ActiveRecord query specifying the output order 
     {:name=>:where,     :type=>GraphQL::STRING_TYPE.to_list_type, :default=>nil, :authorization=>:manage}]  # a string array for use in ActiveRecord query, can be a string or a query/value array to be used by the query ["model.id =? and model.date is not nul]", "1"]
+    {:name=>:scopes,    :type=>ModelScopeList, :default=>nil, :authorization=>:manage}]                    # a list of ModelScopeEnums exposed on the graphql_query/graphql_delete macro, :allowed_scopes and their optional arguments string array
 
 ## graphql_delete
     description:

data/graphql_model_mapper.gemspec

@@ -32,11 +32,13 @@ Gem::Specification.new do |spec|
 
   spec.required_ruby_version = '>= 2.1'
   spec.add_runtime_dependency "graphql", ['>= 1.7.5']
+  spec.add_runtime_dependency "graphql-errors", ['>= 0.1.0']
   spec.add_runtime_dependency "activesupport", ['>= 3.2.22.5']
   spec.add_runtime_dependency "activemodel", ['>= 3.2.22.5']
   spec.add_runtime_dependency "activerecord", ['>= 3.2.22.5']
   spec.add_runtime_dependency "rails", ['>= 3.2.22.5']
   spec.add_development_dependency "graphql", [">= 1.7.5"]
+  spec.add_development_dependency "graphql-errors", ['>= 0.1.0']
   spec.add_development_dependency "bundler", "~> 1.16"
   spec.add_development_dependency "rake", "~> 10.0"
   spec.add_development_dependency "minitest", "~> 5.0"

data/lib/graphql_model_mapper.rb

@@ -6,6 +6,7 @@ require "graphql_model_mapper/query"
 require "graphql_model_mapper/resolve"
 require "graphql_model_mapper/schema"
 require "graphql_model_mapper/utility"
+require "graphql_model_mapper/encryption"
 require "graphql_model_mapper/version"
 require 'graphql_model_mapper/railtie' if defined?(Rails)
 
@@ -20,6 +21,9 @@ module GraphqlModelMapper
   mattr_accessor :scan_for_polymorphic_associations
   mattr_accessor :default_nodes_field
   mattr_accessor :bidirectional_pagination
+  mattr_accessor :handle_errors
+  mattr_accessor :secret_token
+  
   
 
   @@type_case = :camelize
@@ -31,7 +35,8 @@ module GraphqlModelMapper
   @@mutation_resolve_wrapper = nil
   @@default_nodes_field = false
   @@bidirectional_pagination = false
-  
+  @@handle_errors = true
+  @@secret_token = '3eb6db5a9026c547c72708438d496d942e976b252138db7e4e0ee5edd7539457d3ed0fa02ee5e7179420ce5290462018591adaf5f42adcf855da04877827def2'
 
 
   class << self

data/lib/graphql_model_mapper/encryption.rb

@@ -0,0 +1,20 @@
+module GraphqlModelMapper
+  module Encryption
+    def self.key
+      Digest::SHA256.digest(ENV['GRAPHQL_SECRET_TOKEN'] || ENV['SECRET_TOKEN'] || GraphqlModelMapper.secret_token)
+    end
+
+    def self.aes(m,t)
+      (aes = OpenSSL::Cipher::Cipher.new('aes-256-cbc').send(m)).key = Digest::SHA256.digest(self.key)
+      aes.update(t) << aes.final
+    end
+    
+    def self.encode(text)
+      Base64.encode64(aes(:encrypt, text)).strip
+    end
+    
+    def self.decode(text)
+      aes(:decrypt, Base64.decode64(text))
+    end
+  end
+end

data/lib/graphql_model_mapper/mapper_type.rb

@@ -154,7 +154,7 @@ module GraphqlModelMapper
                     end                    
                     if reflection.macro == :has_many
                         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
+                            connection reflection.name.to_sym, -> {GraphqlModelMapper::MapperType.get_connection_type(klass.name, GraphqlModelMapper::MapperType.get_ar_object_with_params(klass.name, type_sub_key: type_sub_key))}, 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
@@ -162,7 +162,7 @@ module GraphqlModelMapper
                                 end
                             end 
                         else
-                            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
+                            field reflection.name.to_sym, -> {GraphqlModelMapper::MapperType.get_list_type(klass.name, 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
@@ -175,7 +175,7 @@ module GraphqlModelMapper
                             # 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 
+                                field reflection.name.to_sym, -> {GraphqlModelMapper::CustomType.const_get(custom_type_name)} 
                             elsif GraphqlModelMapper.scan_for_polymorphic_associations   
                                 field reflection.name.to_sym, -> {GraphqlModelMapper::MapperType.get_polymorphic_type(reflection, name)}, property: reflection.name.to_sym    
                             end 
@@ -209,7 +209,7 @@ module GraphqlModelMapper
                 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
+                        field f.to_sym, GraphqlModelMapper::CustomType.const_get(custom_type_name)
                     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
@@ -235,7 +235,7 @@ module GraphqlModelMapper
             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)
+                types << self.get_ar_object_with_params(p, type_sub_key: :output_type)
             end
 
             ret_type = GraphQL::UnionType.define do
@@ -270,6 +270,74 @@ module GraphqlModelMapper
             params 
         end
     
+
+        def self.get_connection_type(model_name, output_type)
+            connection_type_name = "#{GraphqlModelMapper.get_type_case(GraphqlModelMapper.get_type_name(model_name))}Connection"
+            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.limit(nil).count
+                            #obj.nodes.length  
+                        }
+                    end
+                end
+                GraphqlModelMapper.set_constant(connection_type_name, connection_type)
+            end
+            return GraphqlModelMapper.get_constant(connection_type_name)
+        end
+
+        def self.get_list_type(model_name, output_type)
+            list_type_name = "#{GraphqlModelMapper.get_type_case(GraphqlModelMapper.get_type_name(model_name))}List"     
+            if GraphqlModelMapper.defined_constant?(list_type_name)
+                list_type = GraphqlModelMapper.get_constant(list_type_name)
+            else
+                list_type = GraphQL::ObjectType.define do
+                    name(list_type_name)
+                
+                    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){ GraphqlModelMapper::MapperType.resolve_list(obj,args,ctx) }
+                    end
+                    field :total, -> {GraphQL::INT_TYPE}, hash_key: :total do 
+                        resolve->(obj,args, ctx){
+                            obj.count
+                        }
+                    end
+                end
+                GraphqlModelMapper.set_constant(list_type_name, list_type)
+            end
+            GraphqlModelMapper.get_constant(list_type_name)
+        end
+
+
+        def self.resolve_list(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 requested more items than the maximum page size #{limit}, please reduce your requested per_page entry") 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/limit).ceil
+                raise GraphQL::ExecutionError.new("you requested page #{page} which is greater than the maximum number of pages #{max_page}") if page > max_page
+                obj = obj.offset((page-1)*limit)
+            end
+            obj = obj.limit(limit)
+            obj
+        end
+
         def self.graphql_default_types(
                 input_type: {
                     required_attributes: [], 

data/lib/graphql_model_mapper/mutation.rb

@@ -129,19 +129,31 @@ module GraphqlModelMapper
                 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)
+                scope_enum_type_name = GraphqlModelMapper.get_type_case("#{GraphqlModelMapper.get_type_name(model.name)}Scope_Enum")
+                if !GraphqlModelMapper.defined_constant?(scope_enum_type_name)
                   enum_type = GraphQL::EnumType.define do
-                    name typename
+                    name scope_enum_type_name
                     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
+                  GraphqlModelMapper.set_constant scope_enum_type_name, enum_type
                 end
-                default_arguments << {:name=>:scope, :type=>GraphqlModelMapper.get_constant(typename), :default=>nil, :authorization=>:manage}
-              end
+                #default_arguments << {:name=>:scope, :type=>GraphqlModelMapper.get_constant(typename), :default=>nil, :authorization=>:manage}
+
+                scope_list_type_name = GraphqlModelMapper.get_type_case("#{GraphqlModelMapper.get_type_name(model.name)}Scope_List")
+                if !GraphqlModelMapper.defined_constant?(scope_list_type_name)
+                  scope_list_type =  GraphQL::InputObjectType.define do
+                    name scope_list_type_name
+                    description "scope list for #{GraphqlModelMapper.get_type_name(model.name)}"
+                    argument :scope, !GraphqlModelMapper.get_constant(scope_enum_type_name)
+                    argument :arguments, GraphQL::STRING_TYPE.to_list_type
+                  end
+                  GraphqlModelMapper.set_constant scope_list_type_name, scope_list_type
+                end
+                default_arguments << {:name=>:scopes, :type=>GraphqlModelMapper.get_constant(scope_list_type_name).to_list_type , :default=>nil, :authorization=>:manage}
+              end            
             end
             default_arguments
         end

data/lib/graphql_model_mapper/query.rb

@@ -48,19 +48,31 @@ module GraphqlModelMapper
                 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)
+                scope_enum_type_name = GraphqlModelMapper.get_type_case("#{GraphqlModelMapper.get_type_name(model.name)}Scope_Enum")
+                if !GraphqlModelMapper.defined_constant?(scope_enum_type_name)
                   enum_type = GraphQL::EnumType.define do
-                    name typename
+                    name scope_enum_type_name
                     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
+                  GraphqlModelMapper.set_constant scope_enum_type_name, enum_type
                 end
-                default_arguments << {:name=>:scope, :type=>GraphqlModelMapper.get_constant(typename), :default=>nil, :authorization=>:manage}
-              end
+                #default_arguments << {:name=>:scope, :type=>GraphqlModelMapper.get_constant(typename), :default=>nil, :authorization=>:manage}
+
+                scope_list_type_name = GraphqlModelMapper.get_type_case("#{GraphqlModelMapper.get_type_name(model.name)}Scope_List")
+                if !GraphqlModelMapper.defined_constant?(scope_list_type_name)
+                  scope_list_type =  GraphQL::InputObjectType.define do
+                    name scope_list_type_name
+                    description "scope list for #{GraphqlModelMapper.get_type_name(model.name)}"
+                    argument :scope, !GraphqlModelMapper.get_constant(scope_enum_type_name)
+                    argument :arguments, GraphQL::STRING_TYPE.to_list_type
+                  end
+                  GraphqlModelMapper.set_constant scope_list_type_name, scope_list_type
+                end
+                default_arguments << {:name=>:scopes, :type=>GraphqlModelMapper.get_constant(scope_list_type_name).to_list_type , :default=>nil, :authorization=>:manage}
+              end            
             end
             default_arguments
         end
@@ -92,7 +104,6 @@ module GraphqlModelMapper
 =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
@@ -108,74 +119,30 @@ module GraphqlModelMapper
             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)
-            else
+
+          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
+            if [:deep, :shallow].include?(GraphqlModelMapper.nesting_strategy)
+              connection_type = GraphqlModelMapper::MapperType.get_connection_type(name, output_type)
               total_output_type = GraphQL::ObjectType.define do
                 name total_output_type_name
-                if [:deep, :shallow].include?(GraphqlModelMapper.nesting_strategy)
-                  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 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
-                    }
+                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
-                end
               end
-              GraphqlModelMapper.set_constant(total_output_type_name, total_output_type)
+            else
+                total_output_type = GraphqlModelMapper::MapperType.get_list_type(name, output_type)
             end
+            GraphqlModelMapper.set_constant(total_output_type_name, total_output_type)              
+          end
+
         
               
             ret_type = GraphQL::Field.define do

data/lib/graphql_model_mapper/resolve.rb

@@ -3,6 +3,7 @@ module GraphqlModelMapper
     def self.query_resolver(obj, args, ctx, name)
         #binding.pry
         obj_context = obj || name.classify.constantize
+        model = name.classify.constantize
         select_args = args[:select] || args
     
         if !GraphqlModelMapper.authorized?(ctx, obj_context.name, :query)
@@ -11,16 +12,40 @@ module GraphqlModelMapper
         classmethods = []
         scope_allowed = false
         with_deleted_allowed = false
+
+        if select_args[:scopes]
+          input_scopes = select_args[:scopes]
+          allowed_scopes = []
+          input_scopes.each do |s|
+            if model.public_methods.include?(s[:scope].to_sym)
+              allowed_scopes << {method: s[:scope], args: s[:arguments] }
+            else
+              next
+            end
+          end
+          errors = []
+          allowed_scopes.each do |a|
+            begin
+              obj_context = obj_context.send(a[:method.to_sym], *a[:args])
+            rescue => e
+              errors << "scope method: #{a[:method]} arguments: #{a[:args] || []} error: #{e.message}"
+            end
+          end
+          if errors.length > 0
+            raise GraphQL::ExecutionError.new(errors.join("; "))
+          end
+        end
         if select_args[:scope]
-          classmethods = obj_context.methods - Object.methods
-          scope_allowed = classmethods.include?(select_args[:scope].to_sym)
+          scope_allowed = model.public_methods.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)
+          with_deleted_allowed = model.public_methods.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 with_deleted_allowed && select_args[:with_deleted]
+          obj_context = obj_context.send(:with_deleted)
+        end
 
         implied_includes = self.get_implied_includes(obj_context.name.classify.constantize, ctx.ast_node)
         if !implied_includes.empty? 
@@ -30,8 +55,12 @@ module GraphqlModelMapper
           end
         end
         if select_args[:id]
-
-          type_name, item_id = GraphQL::Schema::UniqueWithinType.decode(select_args[:id])
+          type_name, item_id = nil
+          begin
+            type_name, item_id = GraphQL::Schema::UniqueWithinType.decode(GraphqlModelMapper::Encryption.decode(select_args[:id]))
+          rescue => e
+            raise GraphQL::ExecutionError.new("incorrect global id: unable to resolve id: #{e.message}")
+          end
           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 
@@ -41,7 +70,7 @@ module GraphqlModelMapper
           finder_array = []
           errors = []
           select_args[:ids].each do |id|
-            type_name, item_id = GraphQL::Schema::UniqueWithinType.decode(id)
+            type_name, item_id = GraphQL::Schema::UniqueWithinType.decode(GraphqlModelMapper::Encryption.decode(id))
             if type_name.nil?
               errors << "incorrect global id: unable to resolve type for id:'#{id}'"
               next
@@ -66,9 +95,8 @@ module GraphqlModelMapper
         end
         if select_args[:where]
           obj_context = obj_context.where(select_args[:where])
-        end
-        if with_deleted_allowed
-          obj_context = obj_context.with_deleted
+        else
+          obj_context = obj_context.where("1=1")
         end
         if scope_allowed
           obj_context = obj_context.send(select_args[:scope].to_sym)
@@ -76,15 +104,21 @@ module GraphqlModelMapper
         if select_args[:order]
           obj_context = obj_context.order(select_args[:order])
         end
+        #check for sql errors
+        begin
+          obj_context.eager_load(implied_includes).limit(0).to_a
+        rescue ActiveRecord::StatementInvalid => e
+            raise GraphQL::ExecutionError.new(e.message.sub(" AND (1=1)", "").sub(" LIMIT 0", ""))
+        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]}" : ""))
+          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]}" : "").sub(" AND (1=1)","").sub(" WHERE (1=1)",""))
         end
         #if select_args[:limit].nil?
-        #    obj_context = obj_context.limit(100)
+        #    obj_context = obj_context.limit(GraphqlModelMapper.max_page_size+1)
         #end
-        obj_context = obj_context.where("1=1")
+
         obj_context
     end
 
@@ -105,7 +139,7 @@ module GraphqlModelMapper
         rescue => e
             raise e #GraphQL::ExecutionError.new("error: delete")
         end
-        if model.methods.include?(:with_deleted)
+        if model.public_methods.include?(:with_deleted)
             items.with_deleted
         else
             items
@@ -141,6 +175,10 @@ module GraphqlModelMapper
       selection.name == 'nodes'
     end
 
+    def self.using_items_pagination?(selection)
+      selection.name == 'items'
+    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
@@ -169,6 +207,11 @@ module GraphqlModelMapper
           next
         end
 
+        if using_items_pagination?(selection)
+          get_implied_includes(class_name, selection, dependencies)
+          next
+        end
+
         if using_is_items_collection?(selection)
           get_implied_includes(class_name, selection, dependencies)
           next
@@ -275,10 +318,7 @@ module GraphqlModelMapper
       end
     
       def call(obj, args, ctx)
-        begin
           @resolve_func.call(obj, args, ctx)
-        
-       end
       end
     end
   end

data/lib/graphql_model_mapper/schema.rb

@@ -1,5 +1,5 @@
 module GraphqlModelMapper
-    def self.Schema(log_query_depth: false, log_query_complexity: false, use_backtrace: false, use_authorize: false, nesting_strategy: :deep, type_case: :camelize, max_page_size: 100, scan_for_polymorphic_associations: false, mutation_resolve_wrapper: nil, query_resolve_wrapper: nil, bidirectional_pagination: false, default_nodes_field: false)
+    def self.Schema(log_query_depth: false, log_query_complexity: false, use_backtrace: false, use_authorize: false, nesting_strategy: :deep, type_case: :camelize, max_page_size: 100, scan_for_polymorphic_associations: false, mutation_resolve_wrapper: nil, query_resolve_wrapper: nil, bidirectional_pagination: false, default_nodes_field: false, handle_errors: false, secret_token: nil)
 
       return GraphqlModelMapper.get_constant("GraphqlModelMapperSchema".upcase) if GraphqlModelMapper.defined_constant?("GraphqlModelMapperSchema".upcase)
       GraphqlModelMapper.use_authorize = use_authorize
@@ -9,7 +9,8 @@ module GraphqlModelMapper
       GraphqlModelMapper.scan_for_polymorphic_associations = scan_for_polymorphic_associations
       GraphqlModelMapper.default_nodes_field = default_nodes_field
       GraphqlModelMapper.bidirectional_pagination = bidirectional_pagination
-
+      GraphqlModelMapper.handle_errors = handle_errors
+      
       if query_resolve_wrapper && query_resolve_wrapper < GraphqlModelMapper::Resolve::ResolveWrapper
         GraphqlModelMapper.query_resolve_wrapper = query_resolve_wrapper
       else
@@ -22,6 +23,10 @@ module GraphqlModelMapper
         GraphqlModelMapper.mutation_resolve_wrapper = GraphqlModelMapper::Resolve::ResolveWrapper
       end
 
+      if secret_token
+        GraphqlModelMapper.secret_token = secret_token
+      end
+
 
       GraphQL::Relay::ConnectionType.bidirectional_pagination = GraphqlModelMapper.bidirectional_pagination
       GraphQL::Relay::ConnectionType.default_nodes_field = GraphqlModelMapper.default_nodes_field
@@ -50,11 +55,16 @@ module GraphqlModelMapper
 
         # Create UUIDs by joining the type name & ID, then base64-encoding it
         id_from_object ->(object, type_definition, context) {
-          GraphQL::Schema::UniqueWithinType.encode(type_definition.name, object.id)
+          GraphqlModelMapper::Encryption.encode(GraphQL::Schema::UniqueWithinType.encode(type_definition.name, object.id))
         }
 
         object_from_id ->(id, context) {
-          type_name, item_id = GraphQL::Schema::UniqueWithinType.decode(id)
+          type_name, item_id = nil
+          begin
+            type_name, item_id = GraphQL::Schema::UniqueWithinType.decode(GraphqlModelMapper::Encryption.decode(id))
+          rescue => e
+            raise GraphQL::ExecutionError.new("incorrect global id: unable to resolve id: #{e.message}")            
+          end
           
           type = GraphqlModelMapper.get_constant(type_name.upcase)
           raise GraphQL::ExecutionError.new("unknown type for id: #{id}") if type.nil?
@@ -65,17 +75,6 @@ module GraphqlModelMapper
     
           raise GraphQL::ExecutionError.new("unauthorized access for id: #{id}") if !authorized_proc.call(context, model_name, access_type)
           model = model_name.to_s.classify.constantize
-=begin
-          args = {
-            item_id: item_id
-          }
-          resolver = -> (obj, args, ctx) {              
-            items = GraphqlModelMapper::Resolve.query_resolver(obj, args, ctx, nil)
-          }
-          resolve = GraphqlModelMapper::Query.get_resolver(resolver)
-          resolve.call(model, args, context)
-=end          
-
           model.unscoped.find(item_id)
         }
       end
@@ -83,6 +82,27 @@ module GraphqlModelMapper
      
       schema.query_analyzers << GraphQL::Analysis::QueryDepth.new { |query, depth| Rails.logger.info("[******GraphqlModelMapper Query Depth] #{depth}") } if log_query_depth
       schema.query_analyzers << GraphQL::Analysis::QueryComplexity.new { |query, complexity| Rails.logger.info("[******GraphqlModelMapper Query Complexity] #{complexity}")} if log_query_complexity
+      GraphQL::Errors.configure(schema) do
+        rescue_from ActiveRecord::RecordNotFound do |exception|
+          nil
+        end
+      
+        rescue_from ActiveRecord::StatementInvalid do |exception|
+          GraphQL::ExecutionError.new(exception.message)
+        end
+
+        rescue_from ActiveRecord::RecordInvalid do |exception|
+          GraphQL::ExecutionError.new(exception.record.errors.full_messages.join("\n"))
+        end
+      
+        rescue_from StandardError do |exception|
+          GraphQL::ExecutionError.new(exception.message)
+        end
+
+        rescue_from do |exception|
+          GraphQL::ExecutionError.new(exception.message)
+        end
+      end if GraphqlModelMapper.handle_errors && GraphQL.const_defined?("Errors")
 
       GraphqlModelMapper.set_constant("GraphqlModelMapperSchema".upcase, schema)
       GraphqlModelMapper.get_constant("GraphqlModelMapperSchema".upcase)

data/lib/graphql_model_mapper/utility.rb

@@ -19,6 +19,10 @@ module GraphqlModelMapper
     fields
   end
 
+  def self.generate_secret_token
+    "secret_token: '#{SecureRandom.hex(64)}'"
+  end
+
   def self.schema_mutations
     fields = []
     GraphqlModelMapper.implementations.select{|t| t.public_methods.include?(:graphql_create)}.each { |t|

data/lib/graphql_model_mapper/version.rb

@@ -1,3 +1,3 @@
 module GraphqlModelMapper
-  VERSION = "0.1.0"
+  VERSION = "0.1.1"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: graphql_model_mapper
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.1.1
 platform: ruby
 authors:
 - Gene Black
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2017-11-24 00:00:00.000000000 Z
+date: 2017-11-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: graphql
@@ -24,6 +24,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: 1.7.5
+- !ruby/object:Gem::Dependency
+  name: graphql-errors
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.1.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.1.0
 - !ruby/object:Gem::Dependency
   name: activesupport
   requirement: !ruby/object:Gem::Requirement
@@ -94,6 +108,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: 1.7.5
+- !ruby/object:Gem::Dependency
+  name: graphql-errors
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.1.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.1.0
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
@@ -157,6 +185,7 @@ files:
 - graphql_model_mapper.gemspec
 - lib/graphql_model_mapper.rb
 - lib/graphql_model_mapper/custom_type.rb
+- lib/graphql_model_mapper/encryption.rb
 - lib/graphql_model_mapper/mapper_type.rb
 - lib/graphql_model_mapper/mutation.rb
 - lib/graphql_model_mapper/query.rb