graphoid 0.0.2 → 0.0.4

data/lib/graphoid/drivers/mongoid.rb

@@ -1,68 +1,95 @@
+# frozen_string_literal: true
+
 module Graphoid
   module MongoidDriver
     class << self
-      def through?(type)
+      def through?(_type)
         false
       end
 
+      def mongo_constants
+        begin
+          {
+            many_to_many: Mongoid::Relations::Referenced::ManyToMany,
+            has_many:     Mongoid::Relations::Referenced::Many,
+            belongs_to:   Mongoid::Relations::Referenced::In,
+            has_one:      Mongoid::Relations::Referenced::One,
+            embeds_one:   Mongoid::Relations::Embedded::One,
+            embeds_many:  Mongoid::Relations::Embedded::Many,
+            embedded_in:  Mongoid::Relations::Embedded::In
+          }
+        rescue
+          {
+            many_to_many: Mongoid::Association::Referenced::HasAndBelongsToMany::Proxy,
+            has_many:     Mongoid::Association::Referenced::HasMany::Proxy,
+            belongs_to:   Mongoid::Association::Referenced::BelongsTo::Proxy,
+            has_one:      Mongoid::Association::Referenced::HasOne::Proxy,
+            embeds_one:   Mongoid::Association::Embedded::EmbedsOne::Proxy,
+            embeds_many:  Mongoid::Association::Embedded::EmbedsMany::Proxy,
+            embedded_in:  Mongoid::Association::Embedded::EmbeddedIn::Proxy
+          }
+        end
+      end
+
       def has_and_belongs_to_many?(type)
-        type == Mongoid::Association::Referenced::HasAndBelongsToMany
+        type == mongo_constants[:many_to_many]
       end
 
       def has_many?(type)
-        type == Mongoid::Association::Referenced::HasMany
+        type == mongo_constants[:has_many]
       end
 
       def belongs_to?(type)
-        type == Mongoid::Association::Referenced::BelongsTo
+        type == mongo_constants[:belongs_to]
+        
       end
 
       def has_one?(type)
-        type == Mongoid::Association::Referenced::HasOne
+        type == mongo_constants[:has_one]
       end
 
       def embeds_one?(type)
-        type == Mongoid::Association::Embedded::EmbedsOne
+        type == mongo_constants[:embeds_one]
       end
 
       def embeds_many?(type)
-        type == Mongoid::Association::Embedded::EmbedsMany
+        type == mongo_constants[:embeds_many]
       end
 
       def embedded_in?(type)
-        type == Mongoid::Association::Embedded::EmbeddedIn
+        type == mongo_constants[:embedded_in]
       end
 
       def types_map
         {
-          BSON::ObjectId   => GraphQL::Types::ID,
+          BSON::ObjectId => GraphQL::Types::ID,
           Mongoid::Boolean => GraphQL::Types::Boolean,
-          #Graphoid::Upload    => ApolloUploadServer::Upload,
+          # Graphoid::Upload => ApolloUploadServer::Upload,
 
-          Boolean  => GraphQL::Types::Boolean,
-          Float    => GraphQL::Types::Float,
-          Integer  => GraphQL::Types::Int,
-          String   => GraphQL::Types::String,
-          Object   => GraphQL::Types::String,
-          Symbol   => GraphQL::Types::String,
+          Boolean => GraphQL::Types::Boolean,
+          Float => GraphQL::Types::Float,
+          Integer => GraphQL::Types::Int,
+          String => GraphQL::Types::String,
+          Object => GraphQL::Types::String,
+          Symbol => GraphQL::Types::String,
 
           DateTime => Graphoid::Scalars::DateTime,
-          Time     => Graphoid::Scalars::DateTime,
-          Date     => Graphoid::Scalars::DateTime,
-          Array    => Graphoid::Scalars::Array,
-          Hash     => Graphoid::Scalars::Hash
+          Time => Graphoid::Scalars::DateTime,
+          Date => Graphoid::Scalars::DateTime,
+          Array => Graphoid::Scalars::Array,
+          Hash => Graphoid::Scalars::Hash
         }
       end
 
       def class_of(relation)
         {
-          Mongoid::Association::Referenced::HasAndBelongsToMany => ManyToMany,
-          Mongoid::Association::Referenced::HasMany => HasMany,
-          Mongoid::Association::Referenced::HasOne => HasOne,
-          Mongoid::Association::Referenced::BelongsTo => BelongsTo,
-          Mongoid::Association::Embedded::EmbedsMany => EmbedsMany,
-          Mongoid::Association::Embedded::EmbedsOne => EmbedsOne,
-          Mongoid::Association::Embedded::EmbeddedIn => Relation
+          mongo_constants[:many_to_many]  => ManyToMany,
+          mongo_constants[:has_many]      => HasMany,
+          mongo_constants[:has_one]       => HasOne,
+          mongo_constants[:belongs_to]    => BelongsTo,
+          mongo_constants[:embeds_many]   => EmbedsMany,
+          mongo_constants[:embeds_one]    => EmbedsOne,
+          mongo_constants[:embedded_in]   => Relation
         }[relation.relation] || Relation
       end
 
@@ -88,10 +115,10 @@ module Graphoid
 
       def eager_load(selection, model)
         referenced_relations = [
-          Mongoid::Association::Referenced::HasAndBelongsToMany,
-          Mongoid::Association::Referenced::HasMany,
-          Mongoid::Association::Referenced::HasOne,
-          Mongoid::Association::Referenced::BelongsTo
+          mongo_constants[:many_to_many],
+          mongo_constants[:has_many],
+          mongo_constants[:has_one],
+          mongo_constants[:belongs_to]
         ]
 
         properties = Graphoid::Queries::Processor.children_of(selection)
@@ -108,7 +135,7 @@ module Graphoid
           if (relations & children).empty?
             model = model.includes(name)
           else
-            model = model.includes(name, with: -> (instance) { Graphoid::Queries::Processor.eager_load(subselection, instance) })
+            model = model.includes(name, with: ->(instance) { Graphoid::Queries::Processor.eager_load(subselection, instance) })
           end
         end
 
@@ -126,17 +153,18 @@ module Graphoid
         scope.any_of(list)
       end
 
-      def parse(attribute, value, operator)
+      def parse(attribute, value, operator, prefix = nil)
         field = attribute.name
+        field = "#{prefix}.#{field}" if prefix
         parsed = {}
         case operator
-        when "gt", "gte", "lt", "lte", "in", "nin"
+        when 'gt', 'gte', 'lt', 'lte', 'in', 'nin'
           parsed[field.to_sym.send(operator)] = value
-        when "regex"
+        when 'regex'
           parsed[field.to_sym] = Regexp.new(value.to_s, Regexp::IGNORECASE)
-        when "contains"
+        when 'contains'
           parsed[field.to_sym] = Regexp.new(Regexp.quote(value.to_s), Regexp::IGNORECASE)
-        when "not"
+        when 'not'
           if value.present? && !value.is_a?(Numeric)
             parsed[field.to_sym.send(operator)] = Regexp.new(Regexp.quote(value.to_s), Regexp::IGNORECASE)
           else
@@ -167,17 +195,11 @@ module Graphoid
         field = relation.name
         parsed = {}
 
-        if relation.embeds_one?
-          parsed = relate_embedded(scope, relation, value)
-        end
+        parsed = relate_embedded(scope, relation, value) if relation.embeds_one?
 
-        if relation.belongs_to?
-          parsed = relation.exec(scope, value)
-        end
+        parsed = relation.exec(scope, value) if relation.belongs_to?
 
-        if relation.has_one?
-          parsed = relation.exec(scope, value)
-        end
+        parsed = relation.exec(scope, value) if relation.has_one?
 
         parsed
       end
@@ -191,20 +213,20 @@ module Graphoid
         end
 
         if relation.many_to_many?
-          field_name = field_name.to_s.singularize + "_ids"
-          ids = target.map(&(field_name.to_sym))
+          field_name = field_name.to_s.singularize + '_ids'
+          ids = target.map(&field_name.to_sym)
           ids.flatten!.uniq!
         else
-          field_name = field_name.to_s + "_id"
-          ids = target.map(&(field_name.to_sym))
+          field_name = field_name.to_s + '_id'
+          ids = target.map(&field_name.to_sym)
         end
 
         parsed = {}
-        if operator == "none"
+        if operator == 'none'
           parsed[:id.nin] = ids
-        elsif operator == "some"
+        elsif operator == 'some'
           parsed[:id.in] = ids
-        elsif operator == "every"
+        elsif operator == 'every'
           # missing implementation
         end
         parsed

data/lib/graphoid/graphield.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Graphoid
   module Graphield
     extend ActiveSupport::Concern
@@ -7,20 +9,18 @@ module Graphoid
       @forbidden = {}
 
       class << self
-        def graphield name, type
+        def graphield(name, type)
           @graphields << Graphoid::Attribute.new(name: name.to_s, type: type)
         end
 
-        def graphorbid field, *actions
+        def graphorbid(field, *actions)
           @forbidden[field] = actions
         end
 
-        def graphields
-          @graphields
-        end
+        attr_reader :graphields
 
         def graphfiles
-          @graphields.select{ |field| field.type == Graphoid::Upload }
+          @graphields.select { |field| field.type == Graphoid::Upload }
         end
 
         def forbidden_fields

data/lib/graphoid/grapho.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Graphoid
   class Grapho
     attr_reader :name, :plural, :camel_name

data/lib/graphoid/main.rb

@@ -1,8 +1,10 @@
+# frozen_string_literal: true
+
 module Graphoid
-  @@graphs = {}
+  @graphs = {}
 
   class << self
-    attr_accessor :driver
+    attr_reader :driver
 
     def initialize
       Graphoid.driver = configuration&.driver
@@ -10,8 +12,8 @@ module Graphoid
       Graphoid::Scalars.generate
     end
 
-    def build(model, action = nil)
-      @@graphs[model] ||= Graphoid::Grapho.new(model)
+    def build(model, _action = nil)
+      @graphs[model] ||= Graphoid::Grapho.new(model)
     end
 
     def driver=(driver)

data/lib/graphoid/mapper.rb

@@ -1,8 +1,11 @@
+# frozen_string_literal: true
+
 module Graphoid
   module Mapper
     class << self
-      def convert field
-        return GraphQL::Types::ID if field.name.end_with?("id")
+      def convert(field)
+        return GraphQL::Types::ID if field.name.end_with?('id')
+
         Graphoid.driver.types_map[field.type] || GraphQL::Types::String
       end
     end

data/lib/graphoid/mutations/create.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Graphoid
   module Mutations
     module Create
@@ -22,25 +24,21 @@ module Graphoid
 
         type.class_eval do
           define_method :"#{name}" do |data: {}|
-            begin
-              user = context[:current_user]
-              Graphoid::Mutations::Processor.execute(model, grapho, data, user)
-            rescue Exception => ex
-              GraphQL::ExecutionError.new(ex.message)
-            end
+            user = context[:current_user]
+            Graphoid::Mutations::Processor.execute(model, grapho, data, user)
+          rescue Exception => ex
+            GraphQL::ExecutionError.new(ex.message)
           end
         end
 
         type.class_eval do
           define_method :"#{plural_name}" do |data: []|
-            begin
-              user = context[:current_user]
-              result = []
-              data.each { |d| result << Graphoid::Mutations::Processor.execute(model, grapho, d, user) }
-              result
-            rescue Exception => ex
-              GraphQL::ExecutionError.new(ex.message)
-            end
+            user = context[:current_user]
+            result = []
+            data.each { |d| result << Graphoid::Mutations::Processor.execute(model, grapho, d, user) }
+            result
+          rescue Exception => ex
+            GraphQL::ExecutionError.new(ex.message)
           end
         end
       end

data/lib/graphoid/mutations/delete.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Graphoid
   module Mutations
     module Delete
@@ -22,25 +24,21 @@ module Graphoid
 
         type.class_eval do
           define_method :"#{name}" do |id:|
-            begin
-              result = model.find(id)
-              result.destroy!
-              result
-            rescue Exception => ex
-              GraphQL::ExecutionError.new(ex.message)
-            end
+            result = model.find(id)
+            result.destroy!
+            result
+          rescue Exception => ex
+            GraphQL::ExecutionError.new(ex.message)
           end
         end
 
         type.class_eval do
           define_method :"#{plural}" do |where: {}|
-            begin
-              objects = Graphoid::Queries::Processor.execute(model, where.to_h)
-              objects.destroy_all
-              objects.all.to_a
-            rescue Exception => ex
-              GraphQL::ExecutionError.new(ex.message)
-            end
+            objects = Graphoid::Queries::Processor.execute(model, where.to_h)
+            objects.destroy_all
+            objects.all.to_a
+          rescue Exception => ex
+            GraphQL::ExecutionError.new(ex.message)
           end
         end
       end

data/lib/graphoid/mutations/processor.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Graphoid
   module Mutations
     module Processor
@@ -11,7 +13,7 @@ module Graphoid
           root_object << item if item.present?
         end
 
-        root_object = root_object.reduce(Hash.new, :merge)
+        root_object = root_object.reduce({}, :merge)
 
         fieldnames = Attribute.fieldnames_of(model)
         root_object['created_by_id'] = user.id if fieldnames.include?('created_by_id')

data/lib/graphoid/mutations/structure.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Graphoid
   module Mutations
     extend ActiveSupport::Concern

data/lib/graphoid/mutations/update.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Graphoid
   module Mutations
     module Update

data/lib/graphoid/operators/attribute.rb

@@ -1,8 +1,10 @@
+# frozen_string_literal: true
+
 module Graphoid
   class Attribute
     attr_reader :name, :type
 
-    PERMS = [:read, :create, :update, :delete]
+    PERMS = %i[read create update delete]
 
     def initialize(name:, type:)
       @name = name.to_s
@@ -21,13 +23,12 @@ module Graphoid
     def relation?
       false
     end
-    
+
     def precreate(value)
-      { self.name.to_sym => value }
+      { name.to_sym => value }
     end
 
-    def create(_,_,_)
-    end
+    def create(_, _, _); end
 
     class << self
       def fields_of(model, action = :read)

data/lib/graphoid/operators/inherited/belongs_to.rb

@@ -1,15 +1,17 @@
+# frozen_string_literal: true
+
 module Graphoid
   class BelongsTo < Relation
     def precreate(value)
-      sanitized = Attribute.correct(self.klass, value)
-      foreign_id = self.klass.create!(sanitized).id
-      { :"#{self.name}_id" => foreign_id }
+      sanitized = Attribute.correct(klass, value)
+      foreign_id = klass.create!(sanitized).id
+      { :"#{name}_id" => foreign_id }
     end
-    
+
     def exec(_, value)
-      ids = Graphoid::Queries::Processor.execute(self.klass, value).to_a.map(&:id)
-      attribute = Attribute.new(name: "#{self.name.underscore}_id", type: nil)
-      Graphoid.driver.parse(attribute, ids, "in")
+      ids = Graphoid::Queries::Processor.execute(klass, value).to_a.map(&:id)
+      attribute = Attribute.new(name: "#{name.underscore}_id", type: nil)
+      Graphoid.driver.parse(attribute, ids, 'in')
     end
   end
-end
+end

data/lib/graphoid/operators/inherited/embeds_many.rb

@@ -1,10 +1,24 @@
+# frozen_string_literal: true
+
 module Graphoid
   class EmbedsMany < Relation
     def create(parent, values, _)
       values.each do |value|
-        attributes = Attribute.correct(self.klass, value)
-        parent.send(:"#{self.name}").create!(attributes)
+        attributes = Attribute.correct(klass, value)
+        parent.send(:"#{name}").create!(attributes)
       end
     end
+
+    def exec(_scope, value)
+      _hash = {}
+
+      value.each do |key, _value|
+        operation = Operation.new(klass, key, _value)
+        parsed = Graphoid.driver.parse(operation.operand, operation.value, operation.operator, klass.to_s.underscore.pluralize)
+        _hash.merge!(parsed)
+      end
+
+      _hash
+    end
   end
-end
+end

data/lib/graphoid/operators/inherited/embeds_one.rb

@@ -1,8 +1,22 @@
+# frozen_string_literal: true
+
 module Graphoid
   class EmbedsOne < Relation
     def create(parent, value, _)
-      attrs = Attribute.correct(self.klass, value)
-      parent.send(:"#{self.name}=", attrs)
+      attrs = Attribute.correct(klass, value)
+      parent.send(:"#{name}=", attrs)
+    end
+
+    def exec(_scope, value)
+      _hash = {}
+
+      value.each do |key, _value|
+        operation = Operation.new(klass, key, _value)
+        parsed = Graphoid.driver.parse(operation.operand, operation.value, operation.operator, klass.to_s.underscore)
+        _hash.merge!(parsed)
+      end
+
+      _hash
     end
   end
-end
+end

data/lib/graphoid/operators/inherited/has_many.rb

@@ -1,10 +1,12 @@
+# frozen_string_literal: true
+
 module Graphoid
   class HasMany < Relation
     def create(parent, values, grapho)
       values.each do |value|
-        attributes = Attribute.correct(self.klass, value)
+        attributes = Attribute.correct(klass, value)
         attributes[:"#{grapho.name}_id"] = parent.id
-        self.klass.create!(attributes)
+        klass.create!(attributes)
       end
     end
   end

data/lib/graphoid/operators/inherited/has_one.rb

@@ -1,16 +1,18 @@
+# frozen_string_literal: true
+
 module Graphoid
   class HasOne < Relation
     def create(parent, value, grapho)
-      attributes = Attribute.correct(self.klass, value)
+      attributes = Attribute.correct(klass, value)
       attributes[:"#{grapho.name}_id"] = parent.id
-      self.klass.create!(attributes)
+      klass.create!(attributes)
     end
-    
+
     def exec(scope, value)
-      field_name = self.inverse_name || scope.name.underscore
-      ids = Graphoid::Queries::Processor.execute(self.klass, value).to_a.map(&("#{field_name}_id".to_sym))
-      attribute = Attribute.new(name: "id", type: nil)
-      Graphoid.driver.parse(attribute, ids, "in")
+      field_name = inverse_name || scope.name.underscore
+      ids = Graphoid::Queries::Processor.execute(klass, value).to_a.map(&"#{field_name}_id".to_sym)
+      attribute = Attribute.new(name: 'id', type: nil)
+      Graphoid.driver.parse(attribute, ids, 'in')
     end
   end
 end

data/lib/graphoid/operators/inherited/many_to_many.rb

@@ -1,10 +1,12 @@
+# frozen_string_literal: true
+
 module Graphoid
   class ManyToMany < Relation
     def create(parent, values, grapho)
       values.each do |value|
-        attributes = Attribute.correct(self.klass, value)
+        attributes = Attribute.correct(klass, value)
         attributes[:"#{grapho.name}_ids"] = [parent.id]
-        self.klass.create!(attributes)
+        klass.create!(attributes)
       end
     end
   end

data/lib/graphoid/operators/relation.rb

@@ -1,5 +1,6 @@
-module Graphoid
+# frozen_string_literal: true
 
+module Graphoid
   class Relation
     attr_reader :name, :klass, :type, :inverse_name
 
@@ -11,7 +12,7 @@ module Graphoid
       @type = Graphoid.driver.relation_type(relation)
     end
 
-    [:has_and_belongs_to_many, :through, :has_many, :belongs_to, :has_one, :embeds_one, :embeds_many, :embedded_in].each do |type|
+    %i[has_and_belongs_to_many through has_many belongs_to has_one embeds_one embeds_many embedded_in].each do |type|
       type = :"#{type}?"
       define_method type do
         Graphoid.driver.send(type, @type)
@@ -43,19 +44,17 @@ module Graphoid
       embeds_one? || embeds_many? || embedded_in?
     end
 
-    def precreate(_)
-    end
-    
-    def create(_,_,_)
-    end
+    def precreate(_); end
+
+    def create(_, _, _); end
 
     def resolve(operation)
-      if one?
+      if one? || operation.operand.embedded?
         return operation.operand.exec(operation.scope, operation.value)
       end
 
       if many?
-        return Graphoid.driver.relate_many(o.scope, o.operand, o.value, o.operator)
+        return Graphoid.driver.relate_many(operation.scope, operation.operand, operation.value, operation.operator)
       end
     end
 

data/lib/graphoid/queries/operation.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Graphoid
   class Operation
     attr_reader :scope, :operand, :operator, :value

data/lib/graphoid/queries/processor.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Graphoid
   module Queries
     module Processor
@@ -8,7 +10,7 @@ module Graphoid
         end
 
         def execute_array(scope, list, action)
-          if action == "OR"
+          if action == 'OR'
             scope = Graphoid.driver.execute_or(scope, list)
           else
             list.each { |object| scope = execute(scope, object) }
@@ -17,7 +19,7 @@ module Graphoid
         end
 
         def process(scope, value, key = nil)
-          if key && ["OR", "AND"].exclude?(key)
+          if key && %w[OR AND].exclude?(key)
             operation = Operation.new(scope, key, value)
             filter = operation.resolve
             return Graphoid.driver.execute_and(scope, filter)
@@ -25,12 +27,12 @@ module Graphoid
 
           if operation.nil? || operation.type == :attribute
             return execute(scope, value) if value.is_a?(Hash)
-            if value.is_a?(Array) && ["in", "nin"].exclude?(operation&.operator)
-              return execute_array(scope, value, key) 
+            if value.is_a?(Array) && %w[in nin].exclude?(operation&.operator)
+              return execute_array(scope, value, key)
             end
           end
         end
-        
+
         def children_of(selection)
           selection.scoped_children.values[0]
         end