graphql_model_mapper 0.0.5 → 0.0.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 3caf8e99b813b53bdace0f006ae5b1ef18d14af9
-  data.tar.gz: 5fe2908d454b3c39aaf8d763e6afe595bf8ac3ac
+  metadata.gz: a3de0884a30479b29813d7f124151fb1438942dd
+  data.tar.gz: cc7c0689ccf60fdbe2f85a7f006eef6e3d52891a
 SHA512:
-  metadata.gz: e1d4a123b7354c39b416e808298efe0a7e116c6235dbf0b9fd2afd4c663271d2d041c102a7847cfbaeb7eaff15a53198a9c9ba8fe75ba1105549946e90822854
-  data.tar.gz: f6a53a3dc0dbab8055b13171d5469c1f9f3adf5760f130d2feb77d793b4a3f8c21c6e13f3e6e52b43a1b2b4917703bb6b2d08616bec94d19a1c7b5a332f59b99
+  metadata.gz: 0f8a77c07c0ac1799dc4997e794413a5c08d4450c6f49aa3ba401adeb3251548167ee1195703c1f58600d2c5e7d4fb3109ed64a49ff14441b8d826158de307b4
+  data.tar.gz: c23e038b5a35f578b82d7aa8d8cfd6499e350f3a504001b925d413d1e930a426891808f04367e583a5d59f70dced5aab6cbe43f4304642cf33f4b9c696058131

data/CODE_OF_CONDUCT.md

@@ -0,0 +1,46 @@
+# Contributor Covenant Code of Conduct
+
+## Our Pledge
+
+In the interest of fostering an open and welcoming environment, we as contributors and maintainers pledge to making participation in our project and our community a harassment-free experience for everyone, regardless of age, body size, disability, ethnicity, gender identity and expression, level of experience, nationality, personal appearance, race, religion, or sexual identity and orientation.
+
+## Our Standards
+
+Examples of behavior that contributes to creating a positive environment include:
+
+* Using welcoming and inclusive language
+* Being respectful of differing viewpoints and experiences
+* Gracefully accepting constructive criticism
+* Focusing on what is best for the community
+* Showing empathy towards other community members
+
+Examples of unacceptable behavior by participants include:
+
+* The use of sexualized language or imagery and unwelcome sexual attention or advances
+* Trolling, insulting/derogatory comments, and personal or political attacks
+* Public or private harassment
+* Publishing others' private information, such as a physical or electronic address, without explicit permission
+* Other conduct which could reasonably be considered inappropriate in a professional setting
+
+## Our Responsibilities
+
+Project maintainers are responsible for clarifying the standards of acceptable behavior and are expected to take appropriate and fair corrective action in response to any instances of unacceptable behavior.
+
+Project maintainers have the right and responsibility to remove, edit, or reject comments, commits, code, wiki edits, issues, and other contributions that are not aligned to this Code of Conduct, or to ban temporarily or permanently any contributor for other behaviors that they deem inappropriate, threatening, offensive, or harmful.
+
+## Scope
+
+This Code of Conduct applies both within project spaces and in public spaces when an individual is representing the project or its community. Examples of representing a project or community include using an official project e-mail address, posting via an official social media account, or acting as an appointed representative at an online or offline event. Representation of a project may be further defined and clarified by project maintainers.
+
+## Enforcement
+
+Instances of abusive, harassing, or otherwise unacceptable behavior may be reported by contacting the project team at geblack@hotmail.com. The project team will review and investigate all complaints, and will respond in a way that it deems appropriate to the circumstances. The project team is obligated to maintain confidentiality with regard to the reporter of an incident. Further details of specific enforcement policies may be posted separately.
+
+Project maintainers who do not follow or enforce the Code of Conduct in good faith may face temporary or permanent repercussions as determined by other members of the project's leadership.
+
+## Attribution
+
+This Code of Conduct is adapted from the [Contributor Covenant][homepage], version 1.4, available at [http://contributor-covenant.org/version/1/4][version]
+
+[homepage]: http://contributor-covenant.org
+[version]: http://contributor-covenant.org/version/1/4/

data/Gemfile.lock

@@ -1,10 +1,11 @@
 PATH
   remote: .
   specs:
-    graphql_model_mapper (0.0.5)
+    graphql_model_mapper (0.0.6)
       activemodel (>= 3.2.22.5)
       activerecord (>= 3.2.22.5)
       activesupport (>= 3.2.22.5)
+      graphql (>= 1.7.5)
       rails (>= 3.2.22.5)
 
 GEM

data/README.md

@@ -3,7 +3,7 @@ This project is a work in progress and is in a pre-alpha state. Many thanks to @
 
 The graphql_model_mapper gem facilitates the generation of GraphQL objects based on the definition of your existing ActiveRecord models.
 
-It has been tested on Rails 3.2, 4.1 and 5.0 using Ruby 2.2.8
+It has been tested on Rails 3.2, 4.1 and 5.0 using Ruby 2.1.10 and 2.2.8 
 
 ## Installation
 
@@ -32,87 +32,111 @@ Initially, you will not have any models exposed as GraphQL types. To expose a mo
 
 The default input/output types generated for the model are based on the default settings (which may be overriden by initializing GraphqlModelMapper::GRAPHQL_DEFAULT_TYPES in your own initializer 
 
-Note that the query and delete mutations do not have an input type defined since their arguments are currently generated internally:
-
-    GraphqlModelMapper::GRAPHQL_DEFAULT_TYPES =
-    query: {
-        output_type: {
-            required_attributes: [],    # attributes required in the type - empty list defaults to no required attributes
-            excluded_attributes: [],    # exclude these attributes from the type - empty list defaults to no excluded attributes
-            allowed_attributes: [],     # only allow these attributes in the type - empty list defaults to all attributes allowed
-            foreign_keys: true,         # generate the foreign keys on the type
-            primary_keys: true,         # generate the primary keys for the type
-            validation_keys: false,     # generate non-nullable validation keys for the type
-            association_macro: nil,     # generate the associations fo the type - nil defaults to all associations (other than those that are polymorphic), you may also specify :has_many or :belongs_to or :has_one
-            source_nulls: false,        # use the null definitions that are defined by the database for the exposed attributes
-            type_key: :query,           # internal identifier for the query/mutation type for which this type definition applies
-            type_sub_key: :output_type  # internal sub-identifier for the input/output type for which this definition applies
-        }
-    },
-    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
+    #config/initializers/grapqhql_model_mapper_init.rb
+    GraphqlModelMapper::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
+            }
         },
-        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: {
-        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
+        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
+            }
         },
-        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
+        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
+            }
         }
     }
 
@@ -120,7 +144,7 @@ or individually by using the
 
     graphql_type
     
-macro attribute on the model, passing the individual settings that differ from the defaults. i.e.
+macro attribute on the model, passing the individual settings that differ from the defaults. These will be merged into the default values. i.e.
 
 
     graphql_types query: {
@@ -153,6 +177,115 @@ macro attribute on the model, passing the individual settings that differ from t
       }
     }
 
+or you can specify the **graphql_types** attribute on the model and initialize your own constant for the model in an initializer, these settings will not be merged into the default settings, so you will need to fully elucidate the types
+
+    #config/initializers/grapqhql_model_mapper_init.rb
+    GraphqlModelMapper::[YOUR_MODEL_NAME_CLASSIFIED_AND_CAPITALIZED]_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
+            }
+        }
+    }
 ## Other Options
 
 The query and mutation objects have a default resolver defined that may be sufficient for your needs (with the exception of the create mutation which most likely will not be adequate for your implementation, currently it simply validates the input and does not attempt to add the record). 
@@ -193,7 +326,7 @@ When returning items to populate the appropriate output type, return them as a h
 or
 
     resolver: -> (obj, inputs, ctx){
-        items = YourClass.method_that_returns_an_item(obj, inputs, ctx, name)
+        item = YourClass.method_that_returns_an_item(obj, inputs, ctx, name)
         {
             item: item
         }
@@ -354,7 +487,7 @@ so you may access and test your GraphQL queries. It is located at https://github
 
 you can then reference your previously assigned schema in  app/controllers/graphql_controller.rb
 
-    #app/controllers/graphql_controller
+    #app/controllers/graphql_controller.rb
     class GraphqlController < ApplicationController
         def execute
             variables = ensure_hash(params[:variables])

data/graphql_model_mapper.gemspec

@@ -31,6 +31,7 @@ Gem::Specification.new do |spec|
   spec.require_paths = ["lib"]
 
   spec.required_ruby_version = '>= 2.1'
+  spec.add_runtime_dependency "graphql", ['>= 1.7.5']
   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']

data/lib/graphql_model_mapper.rb

@@ -4,6 +4,7 @@ require "graphql_model_mapper/mutation"
 require "graphql_model_mapper/query"
 require "graphql_model_mapper/resolve"
 require "graphql_model_mapper/schema"
+require "graphql_model_mapper/utility"
 require "graphql_model_mapper/version"
 require 'graphql_model_mapper/railtie' if defined?(Rails)
 
@@ -11,6 +12,10 @@ module GraphqlModelMapper
   mattr_accessor :type_case
   mattr_accessor :nesting_strategy
   mattr_accessor :use_authorize
+
+  @@type_case = :camelize
+  @@nesting_strategy = :shallow
+  @@use_authorize = false
   
   class << self
     attr_writer :logger
@@ -22,207 +27,72 @@ module GraphqlModelMapper
     end
   end
 
-  @@type_case = :camelize
-  @@nesting_strategy = :shallow
-  @@use_authorize = false
   
   def self.included(klazz)
     klazz.extend GraphqlModelMapper_Macros
   end
 
   module GraphqlModelMapper_Macros
-    protected
 
-    def graphql_types(name: self.name, query: {}, update: {}, delete: {}, create: {})
+    protected
+    
+    def graphql_types(query: {}, update: {}, delete: {}, create: {})
+      name = self.name
       define_singleton_method(:graphql_types) do
         GraphqlModelMapper::MapperType.graphql_types(name: name, query: query, update: update, delete: delete, create: create)
       end
     end
 
-    def graphql_update(name: self.name, description:"", resolver: -> (obj, inputs, ctx){
-      GraphqlModelMapper.logger.info "********************update"
+    def graphql_update(description:"", resolver: -> (obj, inputs, ctx){
       item = GraphqlModelMapper::Resolve.update_resolver(obj, inputs, ctx, name)
         {
           item: item
         }
       })
+      name = self.name
       define_singleton_method(:graphql_update) do
         GraphqlModelMapper::Mutation.graphql_update(name: name, description: description, resolver: resolver)
       end
     end
     
-    def graphql_delete(name: self.name, description:"", resolver: -> (obj, inputs, ctx){
-        GraphqlModelMapper.logger.info "********************delete"
+    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: [])
+      name = self.name
       define_singleton_method(:graphql_delete) do
         GraphqlModelMapper::Mutation.graphql_delete(name: name, description: description, resolver: resolver, scope_methods: scope_methods)
       end
     end
     
-    def graphql_create(name: self.name, description:"", resolver:  -> (obj, args, ctx){
-      GraphqlModelMapper.logger.info "********************create"
+    def graphql_create(description:"", resolver:  -> (obj, args, ctx){
       item = GraphqlModelMapper::Resolve.create_resolver(obj, args, ctx, name)
         {
           item: item
         }
       }) 
+      name = self.name
       define_singleton_method(:graphql_create) do
         GraphqlModelMapper::Mutation.graphql_create(name: name, description: description, resolver: resolver)
       end
     end
 
-    def graphql_query(name: self.name, description: "", resolver: -> (obj, args, ctx) {              
+    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)
       end
     end
   end
-
-  def self.implementations
-    Rails.application.eager_load!
-    ActiveRecord::Base.descendants.each.select do |clz|
-      begin
-        clz.included_modules.include?(GraphqlModelMapper) && (clz.public_methods.include?(:graphql_query) || clz.public_methods.include?(:graphql_update) || clz.public_methods.include?(:graphql_delete) || clz.public_methods.include?(:graphql_create) || clz.public_methods.include?(:graphql_types))
-      rescue
-        # it is okay that this is empty - just covering the possibility
-      end
-    end
-  end
-
-  def self.schema_queries
-    fields = []
-    GraphqlModelMapper.implementations.select{|t| t.public_methods.include?(:graphql_query)}.each { |t|      
-      fields << { :name =>GraphqlModelMapper.get_type_case(t.name, false).to_sym, :field => t.graphql_query, :model_name=>t.name, :access_type=>:query }
-    }
-    fields
-  end
-
-  def self.schema_mutations
-    fields = []
-    GraphqlModelMapper.implementations.select{|t| t.public_methods.include?(:graphql_create)}.each { |t|
-      fields << {:name => GraphqlModelMapper.get_type_case("#{GraphqlModelMapper.get_type_name(t.name)}Create", false).to_sym, :field=> t.graphql_create, :model_name=>t.name, :access_type=>:create }
-    }
-    GraphqlModelMapper.implementations.select{|t| t.public_methods.include?(:graphql_update)}.each { |t|
-      fields << {:name =>GraphqlModelMapper.get_type_case("#{GraphqlModelMapper.get_type_name(t.name)}Update", false).to_sym, :field=>t.graphql_update, :model_name=>t.name, :access_type=>:update } 
-    }
-    GraphqlModelMapper.implementations.select{|t| t.public_methods.include?(:graphql_delete)}.each { |t|
-      fields << {:name =>GraphqlModelMapper.get_type_case("#{GraphqlModelMapper.get_type_name(t.name)}Delete", false).to_sym, :field=>t.graphql_delete, :model_name=>t.name, :access_type=>:delete }
-    }
-    fields
-  end
-
-  def self.select_list(model_name, classes=[])
-    model = model_name.classify.constantize
-    output = []
-    columns = model.columns_hash.keys.map{|m| "#{model.name.underscore.pluralize}.#{m}"}
-    relation_includes = model.reflect_on_all_associations.select{|t| begin t.klass rescue next end}.select{|t| !t.options[:polymorphic]}.map{|m| "#{model.name.underscore.pluralize}.#{m.name}"}
-    relations = model.reflect_on_all_associations.select{|t| begin t.klass rescue next end}.select{|t| !t.options[:polymorphic]}
-    relations.each do |a|
-      if !classes.include?(a.klass.name)
-        classes << a.klass.name
-        output = output + GraphqlModelMapper.select_list(a.klass.name, classes)
-      end
-    end
-    output << relation_includes + columns
-    output.sort
-  end
-
-  def self.authorized?(ctx, model_name, access, roles=nil)
-    model = model_name.classify.constantize
-    access = access.to_sym
-    #here it is checking to see if public methods are exposed on items based on the operation being performed
-    if (access && access == :read) || (access && access == :query)
-      access = :read 
-      if !model.public_methods.include?(:graphql_query)
-        return false
-      end
-    elsif access && access == :create
-      if !model.public_methods.include?(:graphql_create)
-        return false
-      end
-    elsif access && access == :update
-      if !model.public_methods.include?(:graphql_update)
-        return false
-      end
-    elsif access && access == :delete
-      if !model.public_methods.include?(:graphql_delete)
-        return false
-      end
-    end
-    if roles && roles.length > 0
-      roles.each do |r|
-        if !ctx[:current_user].hash_role?(role)
-          return false
-        end
-      end
-    end
-    #implementation specific, here it is using an ability method on the user class plugged into cancan
-    if ctx[:current_user].public_methods.include?(:ability)
-      if !ctx[:current_user].ability.can? access, model
-        return false
-      end
-    end
-    true
-  end
- 
-  def self.get_type_name(classname, lowercase_first_letter=false)
-    str = "#{classname.classify.demodulize}"
-    if lowercase_first_letter && str.length > 0
-      str = str[0].downcase + str[1..-1]
-    end
-    str
-  end
-
-  def self.get_type_case(str, uppercase=true)
-    if @@type_case == :camelize
-      if uppercase
-        str.to_s.camelize(:upper)
-      else
-        str.to_s.camelize(:lower)
-      end
-    elsif @@type_case == :underscore
-      if uppercase
-        self.underscore(str)
-      else
-        str.underscore
-      end
-    elsif @@type_case == :classify
-      str
-    else
-      str
-    end
-  end
-
-  def self.underscore(str, upcase=true)
-    if upcase
-      str.split('_').map {|w| w.capitalize}.join('_')
-    else
-      str.underscore
-    end
-  end
-
-  def self.get_constant(type_name)
-    GraphqlModelMapper.const_get(type_name.upcase)
-  end
-
-  def self.set_constant(type_name, type)
-    GraphqlModelMapper.const_set(type_name.upcase, type)
-  end
-
-  def self.defined_constant?(type_name)
-    GraphqlModelMapper.const_defined?(type_name.upcase)
-  end
 end
 
 ActiveRecord::Base.send(:include, GraphqlModelMapper) if defined?(ActiveRecord)

data/lib/graphql_model_mapper/mapper_type.rb

@@ -7,16 +7,17 @@ module GraphqlModelMapper
             delete: {},
             create: {}
             )
-            typesuffix = method(__method__).parameters.map { |arg| eval arg[1].to_s }.hash.abs.to_i.to_s
-            return GraphqlModelMapper.get_constant("#{name.upcase}#{typesuffix}_GRAPHQL_DEFAULT_TYPES") if GraphqlModelMapper.const_defined?("#{name.upcase}#{typesuffix}_GRAPHQL_DEFAULT_TYPES") 
-              
+            #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"
             graphql_type = {}
             graphql_type[:query] = query
             graphql_type[:update] = update
             graphql_type[:delete] = delete
             graphql_type[:create] = create
             merged_graphql_type = self.graphql_default_types.deep_merge(graphql_type)
-            GraphqlModelMapper.set_constant("#{name.upcase}#{typesuffix}_GRAPHQL_DEFAULT_TYPES", merged_graphql_type)
+            GraphqlModelMapper.set_constant("#{name.upcase}_GRAPHQL_DEFAULT_TYPES", merged_graphql_type)
 
             merged_graphql_type
         end
@@ -81,6 +82,7 @@ module GraphqlModelMapper
                     begin
                         klass = reflection.klass
                     rescue
+                        GraphqlModelMapper.logger.warning("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
@@ -124,6 +126,7 @@ module GraphqlModelMapper
                     begin
                         klass = reflection.klass
                     rescue
+                        GraphqlModelMapper.logger.warning("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
@@ -330,7 +333,12 @@ module GraphqlModelMapper
             else
                 case db_sql_type.to_sym #these are strings not symbols
                 when :geometry, :multipolygon, :polygon
-                    nullable ? GraphqlModelMapper::GEOMETRY_TYPE : !GraphqlModelMapper::GEOMETRY_TYPE
+                    case db_type
+                        when :string
+                            nullable ? GraphqlModelMapper::GEOMETRY_OBJECT_TYPE : !GraphqlModelMapper::GEOMETRY_OBJECT_TYPE
+                        else
+                            nullable ? GraphqlModelMapper::GEOMETRY_STRING_TYPE : !GraphqlModelMapper::GEOMETRY_STRING_TYPE
+                    end
                 else
                     nullable ? GraphQL::STRING_TYPE : !GraphQL::STRING_TYPE
                 end

data/lib/graphql_model_mapper/resolve.rb

@@ -20,7 +20,9 @@ module GraphqlModelMapper
               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 = GraphqlModelMapper::Resolve.get_implied_includes(obj_context, GraphqlModelMapper::Resolve.get_include_fields(ctx))
+
+            implied_includes = self.get_implied_includes(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
@@ -99,50 +101,66 @@ module GraphqlModelMapper
             item
         end
 
+          def self.using_relay_pagination?(selection)
+          selection.name == 'edges'
+        end
+    
+        def self.using_is_items_collection?(selection)
+          selection.name == 'items'
+        end
 
-          # build includes list for associated tables in use in the query, skips [:nodes, :edges] and result entries while walking references
-        def self.get_implied_includes(model, field_names=nil, first=true, org_field_names=nil, resolve_fields=false)
-            if first
-            org_field_names = field_names
-            # associations fields that are on the model
-            a = field_names.select{|m| model.reflect_on_all_associations.map(&:name).include?(m[:name].to_sym)}.select{|m| field_names.map{|m| m[:parent_line]}.include?(m[:line])}
-            # base field names that have no parent, get the lowest number parent_line on the associated field names
-            a = a.select{|o| o[:parent_line] == a.map{|v| v[:parent_line]}.sort.first}
-            else
-            a = field_names
-            end
-            final_out = []
-            a.each do |b|
-            out = []
-                child_relations = org_field_names.select{|g| g[:parent_line] == b[:line]}
-                if !child_relations.empty?
-                children = GraphqlModelMapper::Resolve.get_implied_includes(nil, child_relations, false, org_field_names, resolve_fields)
-                if children.empty?
-                    out << b[:name].to_sym if ![:edges, :node].include?(b[:name].to_sym)
-                else
-                    if ![:edges, :node].include?(b[:name].to_sym)
-                    out << { b[:name].to_sym => children.flatten }
-                    else
-                    out = children.flatten
-                    end
-                end
-                end
-                if resolve_fields && out.empty?
-                out << b[:name].to_sym
-                end
-                final_out << out if !out.empty?
-            end
-            final_out
+        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.get_include_fields(ctx)
-            fieldnames = []
-            visitor = GraphQL::Language::Visitor.new(ctx.query.document)
-            visitor[GraphQL::Language::Nodes::Field] << ->(node, parent) { fieldnames << {:line=>node.line, :parent_line=>parent.line, :parent=>parent.name, :name=>node.name} }
-            visitor.visit
-            fieldnames
+        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
+    
+            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
+            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
+            end
+          end
+          dependencies
+        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

data/lib/graphql_model_mapper/schema.rb

@@ -80,20 +80,52 @@ module GraphqlModelMapper
     end
   end
 
-  GraphqlModelMapper::GEOMETRY_TYPE = GraphQL::ScalarType.define do
-    name "Geometry"
+  GraphqlModelMapper::GEOMETRY_OBJECT_TYPE = GraphQL::ScalarType.define do
+    name "GeometryObject"
     description "The Geometry scalar type enables the serialization of Geometry data"
-  
+    require 'geo_ruby/geojson' if !defined?(GeoRuby).nil?
+
     coerce_input ->(value, ctx) do
         begin
-            value.nil? ? nil : GeoRuby::SimpleFeatures::Geometry.from_geojson(value)
+            if value.nil? 
+              nil 
+            elsif !defined?(GeoRuby::GeojsonParser).nil?
+              GeoRuby::SimpleFeatures::Geometry.from_geojson(value) 
+            elsif !defined?(RGeo::GeoJSON).nil?
+              RGeo::GeoJSON.decode(value, json_parser: :json)
+            else 
+              raise ArgumentError
+            end
         rescue ArgumentError
             raise GraphQL::CoercionError, "cannot coerce `#{value.inspect}` to json"
         end
     end
-    coerce_result ->(value, ctx) { value.nil? ? "" : value.to_json }
+    coerce_result ->(value, ctx) { (value.nil? ? "" : (defined?(GeoRuby) == "constant" && value.kind_of?(GeoRuby::SimpleFeatures::Geometry) ? value.to_json : (defined?(RGeo) == "constant" && defined?(RGeo::GeoJSON) == "constant" && RGeo::Geos.is_capi_geos?(value) ? RGeo::GeoJSON.encode(value).to_json : value))) }
   end
   
+  GraphqlModelMapper::GEOMETRY_STRING_TYPE = GraphQL::ScalarType.define do
+    name "GeometryString"
+    description "The Geometry scalar type enables the serialization of Geometry data"
+    require 'geo_ruby/geojson' if !defined?(GeoRuby).nil?
+
+    coerce_input ->(value, ctx) do
+        begin
+            if value.nil? 
+              nil 
+            elsif !defined?(GeoRuby::GeojsonParser).nil?
+              GeoRuby::SimpleFeatures::Geometry.from_geojson(value).as_wkt 
+            elsif !defined?(RGeo::GeoJSON).nil?
+              RGeo::GeoJSON.decode(value, json_parser: :json).as_text
+            else 
+              raise ArgumentError
+            end
+        rescue ArgumentError
+            raise GraphQL::CoercionError, "cannot coerce `#{value.inspect}` to json"
+        end
+    end
+    coerce_result ->(value, ctx) { (value.nil? ? "" : (defined?(GeoRuby) == "constant" && value.kind_of?(GeoRuby::SimpleFeatures::Geometry) ? value.to_json : (defined?(RGeo) == "constant" && defined?(RGeo::GeoJSON) == "constant" && RGeo::Geos.is_capi_geos?(value) ? RGeo::GeoJSON.encode(value).to_json : value))) }
+  end
+
   GraphqlModelMapper::DATE_TYPE = GraphQL::ScalarType.define do
     name "Date"
     description "The Date scalar type enables the serialization of date data to/from iso8601"

data/lib/graphql_model_mapper/utility.rb

@@ -0,0 +1,137 @@
+module GraphqlModelMapper
+
+  def self.implementations
+    Rails.application.eager_load!
+    ActiveRecord::Base.descendants.each.select do |clz|
+      begin
+        clz.included_modules.include?(GraphqlModelMapper) && (clz.public_methods.include?(:graphql_query) || clz.public_methods.include?(:graphql_update) || clz.public_methods.include?(:graphql_delete) || clz.public_methods.include?(:graphql_create) || clz.public_methods.include?(:graphql_types))
+      rescue
+        # it is okay that this is empty - just covering the possibility
+      end
+    end
+  end
+
+  def self.schema_queries
+    fields = []
+    GraphqlModelMapper.implementations.select{|t| t.public_methods.include?(:graphql_query)}.each { |t|      
+      fields << { :name =>GraphqlModelMapper.get_type_case(t.name, false).to_sym, :field => t.graphql_query, :model_name=>t.name, :access_type=>:query }
+    }
+    fields
+  end
+
+  def self.schema_mutations
+    fields = []
+    GraphqlModelMapper.implementations.select{|t| t.public_methods.include?(:graphql_create)}.each { |t|
+      fields << {:name => GraphqlModelMapper.get_type_case("#{GraphqlModelMapper.get_type_name(t.name)}Create", false).to_sym, :field=> t.graphql_create, :model_name=>t.name, :access_type=>:create }
+    }
+    GraphqlModelMapper.implementations.select{|t| t.public_methods.include?(:graphql_update)}.each { |t|
+      fields << {:name =>GraphqlModelMapper.get_type_case("#{GraphqlModelMapper.get_type_name(t.name)}Update", false).to_sym, :field=>t.graphql_update, :model_name=>t.name, :access_type=>:update } 
+    }
+    GraphqlModelMapper.implementations.select{|t| t.public_methods.include?(:graphql_delete)}.each { |t|
+      fields << {:name =>GraphqlModelMapper.get_type_case("#{GraphqlModelMapper.get_type_name(t.name)}Delete", false).to_sym, :field=>t.graphql_delete, :model_name=>t.name, :access_type=>:delete }
+    }
+    fields
+  end
+
+  def self.select_list(model_name, classes=[])
+    model = model_name.classify.constantize
+    output = []
+    columns = model.columns_hash.keys.map{|m| "#{model.name.underscore.pluralize}.#{m}"}
+    relation_includes = model.reflect_on_all_associations.select{|t| begin t.klass rescue next end}.select{|t| !t.options[:polymorphic]}.map{|m| "#{model.name.underscore.pluralize}.#{m.name}"}
+    relations = model.reflect_on_all_associations.select{|t| begin t.klass rescue next end}.select{|t| !t.options[:polymorphic]}
+    relations.each do |a|
+      if !classes.include?(a.klass.name)
+        classes << a.klass.name
+        output = output + GraphqlModelMapper.select_list(a.klass.name, classes)
+      end
+    end
+    output << relation_includes + columns
+    output.sort
+  end
+
+  def self.authorized?(ctx, model_name, access, roles=nil)
+    model = model_name.classify.constantize
+    access = access.to_sym
+    #here it is checking to see if public methods are exposed on items based on the operation being performed
+    if (access && access == :read) || (access && access == :query)
+      access = :read 
+      if !model.public_methods.include?(:graphql_query)
+        return false
+      end
+    elsif access && access == :create
+      if !model.public_methods.include?(:graphql_create)
+        return false
+      end
+    elsif access && access == :update
+      if !model.public_methods.include?(:graphql_update)
+        return false
+      end
+    elsif access && access == :delete
+      if !model.public_methods.include?(:graphql_delete)
+        return false
+      end
+    end
+    if roles && roles.length > 0
+      roles.each do |r|
+        if !ctx[:current_user].hash_role?(role)
+          return false
+        end
+      end
+    end
+    #implementation specific, here it is using an ability method on the user class plugged into cancan
+    if ctx[:current_user].public_methods.include?(:ability)
+      if !ctx[:current_user].ability.can? access, model
+        return false
+      end
+    end
+    true
+  end
+ 
+  def self.get_type_name(classname, lowercase_first_letter=false)
+    str = "#{classname.classify.demodulize}"
+    if lowercase_first_letter && str.length > 0
+      str = str[0].downcase + str[1..-1]
+    end
+    str
+  end
+
+  def self.get_type_case(str, uppercase=true)
+    if @@type_case == :camelize
+      if uppercase
+        str.to_s.camelize(:upper)
+      else
+        str.to_s.camelize(:lower)
+      end
+    elsif @@type_case == :underscore
+      if uppercase
+        self.underscore(str)
+      else
+        str.underscore
+      end
+    elsif @@type_case == :classify
+      str
+    else
+      str
+    end
+  end
+
+  def self.underscore(str, upcase=true)
+    if upcase
+      str.split('_').map {|w| w.capitalize}.join('_')
+    else
+      str.underscore
+    end
+  end
+
+  def self.get_constant(type_name)
+    GraphqlModelMapper.const_get(type_name.upcase)
+  end
+
+  def self.set_constant(type_name, type)
+    GraphqlModelMapper.const_set(type_name.upcase, type)
+  end
+
+  def self.defined_constant?(type_name)
+    GraphqlModelMapper.const_defined?(type_name.upcase)
+  end
+end  

data/lib/graphql_model_mapper/version.rb

@@ -1,3 +1,3 @@
 module GraphqlModelMapper
-  VERSION = "0.0.5"
+  VERSION = "0.0.6"
 end

metadata

@@ -1,15 +1,29 @@
 --- !ruby/object:Gem::Specification
 name: graphql_model_mapper
 version: !ruby/object:Gem::Version
-  version: 0.0.5
+  version: 0.0.6
 platform: ruby
 authors:
 - Gene Black
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2017-11-13 00:00:00.000000000 Z
+date: 2017-11-14 00:00:00.000000000 Z
 dependencies:
+- !ruby/object:Gem::Dependency
+  name: graphql
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.7.5
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.7.5
 - !ruby/object:Gem::Dependency
   name: activesupport
   requirement: !ruby/object:Gem::Requirement
@@ -132,6 +146,7 @@ extra_rdoc_files: []
 files:
 - ".gitignore"
 - ".travis.yml"
+- CODE_OF_CONDUCT.md
 - Gemfile
 - Gemfile.lock
 - LICENSE.txt
@@ -147,7 +162,6 @@ files:
 - lib/graphql_model_mapper/railtie.rb
 - lib/graphql_model_mapper/resolve.rb
 - lib/graphql_model_mapper/schema.rb
-- lib/graphql_model_mapper/schema_types.rb
 - lib/graphql_model_mapper/utility.rb
 - lib/graphql_model_mapper/version.rb
 homepage: https://github.com/geneeblack/graphql_model_mapper