graphql_model_mapper 0.0.2

data/lib/graphql_model_mapper/resolve.rb

@@ -0,0 +1,221 @@
+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 = GraphqlModelMapper::Resolve.get_implied_includes(obj_context, GraphqlModelMapper::Resolve.get_include_fields(ctx))
+            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
+        end
+
+        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.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
+        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
+        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
+        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
+        
+            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    

data/lib/graphql_model_mapper/schema.rb

@@ -0,0 +1,110 @@
+module GraphqlModelMapper
+    def self.Schema(log_query_depth: false, log_query_complexity: false, use_backtrace: false, use_authorize: false, nesting_strategy: :shallow, type_case: :camelize)
+
+      return GraphqlModelMapper.get_constant("GraphqlModelMapperSchema".upcase) if GraphqlModelMapper.defined_constant?("GraphqlModelMapperSchema".upcase)
+      GraphqlModelMapper.use_authorize = use_authorize
+      GraphqlModelMapper.nesting_strategy = nesting_strategy
+      GraphqlModelMapper.type_case = type_case
+
+      if GraphqlModelMapper.use_authorize
+        metadata_definitions = {
+          authorized: ->(field, authorized_proc) { field.metadata[:authorized_proc] = authorized_proc },
+          model_name: GraphQL::Define.assign_metadata_key(:model_name),
+          access_type: GraphQL::Define.assign_metadata_key(:access_type)
+        }
+        GraphQL::Field.accepts_definitions(metadata_definitions)
+        GraphQL::Argument.accepts_definitions(metadata_definitions)
+      end
+
+      schema = GraphQL::Schema.define do
+        use GraphQL::Backtrace if use_backtrace
+        default_max_page_size 100
+        mutation GraphqlModelMapper.MutationType
+        query GraphqlModelMapper.QueryType
+      end
+
+     
+      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
+
+      GraphqlModelMapper.set_constant("GraphqlModelMapperSchema".upcase, schema)
+
+    end
+
+
+    def self.QueryType
+      return GraphQL::ObjectType.define do
+        name 'Query'
+        # create queries for each AR model object
+        field :welcomeQuery, types.String, hash_key: :welcomeMutation do
+          resolve -> (obj, args, ctx){
+            {
+              welcomeQuery: "this is a placeholder mutation in case you do not have access to other queries"
+            }
+          }
+        end
+        GraphqlModelMapper.schema_queries.each do |f|
+          field f[:name], f[:field]  do
+            if GraphqlModelMapper.use_authorize
+              authorized ->(ctx, model_name, access_type) { GraphqlModelMapper.authorized?(ctx, model_name, access_type.to_sym) }
+              model_name f[:model_name]
+              access_type f[:access_type].to_s
+            end
+          end   
+        end
+      end
+    end
+
+    def self.MutationType
+      return GraphQL::ObjectType.define do
+        name 'Mutation'
+      
+        field :welcomeMutation, types.String, hash_key: :welcomeMutation do
+          resolve -> (obj, args, ctx){
+            {
+              welcomeMutation: "this is a placeholder mutation in case you do not have access to other mutations"
+            }
+          }
+        end
+    
+        GraphqlModelMapper.schema_mutations.each do |f|
+          field f[:name], f[:field]  do
+            if GraphqlModelMapper.use_authorize
+              authorized ->(ctx, model_name, access_type) { GraphqlModelMapper.authorized?(ctx, model_name, access_type.to_sym) }
+              model_name  f[:model_name]
+              access_type f[:access_type].to_s
+            end
+          end
+        end   
+      end
+    end
+  end
+
+  GraphqlModelMapper::GEOMETRY_TYPE = GraphQL::ScalarType.define do
+    name "Geometry"
+    description "The Geometry scalar type enables the serialization of Geometry data"
+  
+    coerce_input ->(value, ctx) do
+        begin
+            value.nil? ? nil : GeoRuby::SimpleFeatures::Geometry.from_geojson(value)
+        rescue ArgumentError
+            raise GraphQL::CoercionError, "cannot coerce `#{value.inspect}` to json"
+        end
+    end
+    coerce_result ->(value, ctx) { value.nil? ? "" : value.to_json }
+  end
+  
+  GraphqlModelMapper::DATE_TYPE = GraphQL::ScalarType.define do
+    name "Date"
+    description "The Date scalar type enables the serialization of date data to/from iso8601"
+  
+    coerce_input ->(value, ctx) do
+        begin
+            value.nil? ? nil :  Date.iso8601(value)
+        rescue ArgumentError
+            raise GraphQL::CoercionError, "cannot coerce `#{value.inspect}` to date"
+        end
+    end
+    coerce_result ->(value, ctx) { value.nil? ? nil : value.iso8601 }
+  end
+  

data/lib/graphql_model_mapper/version.rb

@@ -0,0 +1,3 @@
+module GraphqlModelMapper
+  VERSION = "0.0.2"
+end

data/lib/graphql_model_mapper.rb

@@ -0,0 +1,228 @@
+require "graphql"
+require "graphql_model_mapper/mapper_type"
+require "graphql_model_mapper/mutation"
+require "graphql_model_mapper/query"
+require "graphql_model_mapper/resolve"
+require "graphql_model_mapper/schema"
+require "graphql_model_mapper/version"
+require 'graphql_model_mapper/railtie' if defined?(Rails)
+
+module GraphqlModelMapper
+  mattr_accessor :type_case
+  mattr_accessor :nesting_strategy
+  mattr_accessor :use_authorize
+  
+  class << self
+    attr_writer :logger
+
+    def logger
+      @logger ||= Logger.new($stdout).tap do |log|
+        log.progname = self.name
+      end
+    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: {})
+      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"
+      item = GraphqlModelMapper::Resolve.update_resolver(obj, inputs, ctx, name)
+        {
+          item: item
+        }
+      })
+      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"
+        items = GraphqlModelMapper::Resolve.delete_resolver(obj, inputs, ctx, name)
+        {
+          total: items.length,
+          items: items
+        }
+      }, arguments: [], scope_methods: [])
+      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"
+      item = GraphqlModelMapper::Resolve.create_resolver(obj, args, ctx, name)
+        {
+          item: item
+        }
+      }) 
+      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) {              
+        items = GraphqlModelMapper::Resolve.query_resolver(obj, args, ctx, name)
+        {
+          items: items,
+          total: items.length
+        }
+      }, arguments: [], scope_methods: [])                      
+      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)

metadata

@@ -0,0 +1,122 @@
+--- !ruby/object:Gem::Specification
+name: graphql_model_mapper
+version: !ruby/object:Gem::Version
+  version: 0.0.2
+platform: ruby
+authors:
+- Gene Black
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2017-11-13 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: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.7.5
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.16'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.16'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+description: This gem extends ActiveRecord::Base to add automatic generation of GraphQL
+  objects based on your models.
+email:
+- geblack@hotmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".travis.yml"
+- Gemfile
+- Gemfile.lock
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- graphql_model_mapper.gemspec
+- lib/graphql_model_mapper.rb
+- lib/graphql_model_mapper/mapper_type.rb
+- lib/graphql_model_mapper/mutation.rb
+- lib/graphql_model_mapper/query.rb
+- 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/geneblack/graphql_model_mapper
+licenses:
+- MIT
+metadata:
+  allowed_push_host: https://rubygems.org
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.6.14
+signing_key: 
+specification_version: 4
+summary: Adds GraphQL object generation based on your ActiveRecord models.
+test_files: []