graphoid 0.0.1

data/lib/graphoid/drivers/mongoid.rb

@@ -0,0 +1,214 @@
+module Graphoid
+  module MongoidDriver
+    class << self
+      def through?(type)
+        false
+      end
+
+      def has_and_belongs_to_many?(type)
+        type == Mongoid::Association::Referenced::HasAndBelongsToMany
+      end
+
+      def has_many?(type)
+        type == Mongoid::Association::Referenced::HasMany
+      end
+
+      def belongs_to?(type)
+        type == Mongoid::Association::Referenced::BelongsTo
+      end
+
+      def has_one?(type)
+        type == Mongoid::Association::Referenced::HasOne
+      end
+
+      def embeds_one?(type)
+        type == Mongoid::Association::Embedded::EmbedsOne
+      end
+
+      def embeds_many?(type)
+        type == Mongoid::Association::Embedded::EmbedsMany
+      end
+
+      def embedded_in?(type)
+        type == Mongoid::Association::Embedded::EmbeddedIn
+      end
+
+      def types_map
+        {
+          BSON::ObjectId   => GraphQL::Types::ID,
+          Mongoid::Boolean => GraphQL::Types::Boolean,
+          #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,
+
+          DateTime => Graphoid::Scalars::DateTime,
+          Time     => Graphoid::Scalars::DateTime,
+          Date     => Graphoid::Scalars::DateTime,
+          Array    => Graphoid::Scalars::Array,
+          Hash     => Graphoid::Scalars::Hash
+        }
+      end
+
+      def class_of(relation)
+        {
+          Mongoid::Relations::Referenced::ManyToMany => ManyToMany,
+          Mongoid::Relations::Referenced::Many => HasMany,
+          Mongoid::Relations::Referenced::One => HasOne,
+          Mongoid::Relations::Referenced::In => BelongsTo,
+          Mongoid::Relations::Embedded::Many => EmbedsMany,
+          Mongoid::Relations::Embedded::One => EmbedsOne,
+          Mongoid::Relations::Embedded::In => Relation
+        }[relation.relation] || Relation
+      end
+
+      def inverse_name_of(relation)
+        relation.inverse_of
+      end
+
+      def fields_of(model)
+        model.respond_to?(:fields) ? model.fields.values : []
+      end
+
+      def relations_of(model)
+        model.relations
+      end
+
+      def skip(result, skip)
+        result.skip(skip)
+      end
+
+      def relation_type(relation)
+        relation.relation
+      end
+
+      def eager_load(selection, model)
+        referenced_relations = [
+          Mongoid::Relations::Referenced::ManyToMany,
+          Mongoid::Relations::Referenced::Many,
+          Mongoid::Relations::Referenced::One,
+          Mongoid::Relations::Referenced::In
+        ]
+
+        properties = Graphoid::Queries::Processor.children_of(selection)
+        inclusions = Utils.symbolize(properties)
+
+        Relation.relations_of(model).each do |name, relation|
+          name = relation.name
+          next if inclusions.exclude?(name) || referenced_relations.exclude?(association.relation)
+
+          subselection = properties[name.to_s.camelize(:lower)]
+          children = Utils.symbolize(Graphoid::Queries::Processor.children_of(subselection))
+          relations = relation.class_name.constantize.reflections.values.map(&:name)
+
+          if (relations & children).empty?
+            model = model.includes(name)
+          else
+            model = model.includes(name, with: -> (instance) { Graphoid::Queries::Processor.eager_load(subselection, instance) })
+          end
+        end
+
+        model
+      end
+
+      def execute_and(scope, parsed)
+        scope.and(parsed)
+      end
+
+      def execute_or(scope, list)
+        list.map! do |object|
+          Graphoid::Queries::Processor.execute(scope, object).selector
+        end
+        scope.any_of(list)
+      end
+
+      def parse(attribute, value, operator)
+        field = attribute.name
+        parsed = {}
+        case operator
+        when "gt", "gte", "lt", "lte", "in", "nin"
+          parsed[field.to_sym.send(operator)] = value
+        when "regex"
+          parsed[field.to_sym] = Regexp.new(value.to_s, Regexp::IGNORECASE)
+        when "contains"
+          parsed[field.to_sym] = Regexp.new(Regexp.quote(value.to_s), Regexp::IGNORECASE)
+        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
+            parsed[field.to_sym.send(:nin)] = [value]
+          end
+        else
+          parsed[field.to_sym] = value
+        end
+        parsed
+      end
+
+      def relate_embedded(scope, relation, filters)
+        # TODO: this way of fetching this is not recursive as the regular fields
+        # because the structure of the query is embeeded.field = value
+        # we need more brain cells on this problem because it does not allow
+        # to filter things using OR/AND
+        parsed = {}
+        filters.each do |key, value|
+          operation = Operation.new(scope, key, value)
+          attribute = OpenStruct.new(name: "#{relation.name}.#{operation.operand}")
+          obj = parse(attribute, value, operation.operator).first
+          parsed[obj[0]] = obj[1]
+        end
+        parsed
+      end
+
+      def relate_one(scope, relation, value)
+        field = relation.name
+        parsed = {}
+
+        if relation.embeds_one?
+          parsed = relate_embedded(scope, relation, value)
+        end
+
+        if relation.belongs_to?
+          parsed = relation.exec(scope, value)
+        end
+
+        if relation.has_one?
+          parsed = relation.exec(scope, value)
+        end
+
+        parsed
+      end
+
+      def relate_many(scope, relation, value, operator)
+        field_name = relation.inverse_name || scope.name.underscore
+        target = Graphoid::Queries::Processor.execute(relation.klass, value).to_a
+
+        if relation.embeds_many?
+          # TODO: not implemented at all.
+        end
+
+        if relation.many_to_many?
+          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))
+        end
+
+        parsed = {}
+        if operator == "none"
+          parsed[:id.nin] = ids
+        elsif operator == "some"
+          parsed[:id.in] = ids
+        elsif operator == "every"
+          # missing implementation
+        end
+        parsed
+      end
+    end
+  end
+end

data/lib/graphoid/graphield.rb

@@ -0,0 +1,32 @@
+module Graphoid
+  module Graphield
+    extend ActiveSupport::Concern
+
+    included do
+      @graphields = []
+      @forbidden = {}
+
+      class << self
+        def graphield name, type
+          @graphields << Graphoid::Attribute.new(name: name.to_s, type: type)
+        end
+
+        def graphorbid field, *actions
+          @forbidden[field] = actions
+        end
+
+        def graphields
+          @graphields
+        end
+
+        def graphfiles
+          @graphields.select{ |field| field.type == Graphoid::Upload }
+        end
+
+        def forbidden_fields
+          @forbidden
+        end
+      end
+    end
+  end
+end

data/lib/graphoid/grapho.rb

@@ -0,0 +1,23 @@
+module Graphoid
+  class Grapho
+    attr_reader :name, :plural, :camel_name
+    attr_reader :type, :filter, :order, :input
+
+    def initialize(model)
+      build_naming(model)
+
+      @type   = Graphoid::Types.generate(model)
+      @order  = Graphoid::Orders.generate(model)
+      @input  = Graphoid::Inputs.generate(model)
+      @filter = Graphoid::Filters.generate(model)
+    end
+
+    private
+
+    def build_naming(model)
+      @camel_name = Utils.graphqlize(model.name)
+      @name = @camel_name.underscore
+      @plural = @name.pluralize
+    end
+  end
+end

data/lib/graphoid/main.rb

@@ -0,0 +1,21 @@
+module Graphoid
+  @@graphs = {}
+
+  class << self
+    attr_accessor :driver
+
+    def initialize
+      Graphoid.driver = configuration&.driver
+      Rails.application.eager_load!
+      Graphoid::Scalars.generate
+    end
+
+    def build(model, action = nil)
+      @@graphs[model] ||= Graphoid::Grapho.new(model)
+    end
+
+    def driver=(driver)
+      @driver = driver == :active_record ? ActiveRecordDriver : MongoidDriver
+    end
+  end
+end

data/lib/graphoid/mapper.rb

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

data/lib/graphoid/mutations/create.rb

@@ -0,0 +1,49 @@
+module Graphoid
+  module Mutations
+    module Create
+      extend ActiveSupport::Concern
+
+      included do
+        Graphoid.initialize
+        model = self
+        grapho = Graphoid.build(model)
+        type = ::Types::MutationType
+
+        name = "create_#{grapho.name}"
+        plural_name = name.pluralize
+
+        type.field(name: name, type: grapho.type, null: true) do
+          argument(:data, grapho.input, required: false)
+        end
+
+        type.field(name: plural_name, type: [grapho.type], null: true) do
+          argument(:data, [grapho.input], required: false)
+        end
+
+        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
+          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
+          end
+        end
+      end
+    end
+  end
+end

data/lib/graphoid/mutations/delete.rb

@@ -0,0 +1,49 @@
+module Graphoid
+  module Mutations
+    module Delete
+      extend ActiveSupport::Concern
+
+      included do
+        Graphoid.initialize
+        model = self
+        grapho = Graphoid.build(model)
+        type = ::Types::MutationType
+
+        name = "delete_#{grapho.name}"
+        plural = "delete_many_#{grapho.plural}"
+
+        type.field(name: name, type: grapho.type, null: true) do
+          argument :id, GraphQL::Types::ID, required: true
+        end
+
+        type.field(name: plural, type: [grapho.type], null: true) do
+          argument :where, grapho.filter, required: false
+        end
+
+        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
+          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
+          end
+        end
+      end
+    end
+  end
+end

data/lib/graphoid/mutations/processor.rb

@@ -0,0 +1,31 @@
+module Graphoid
+  module Mutations
+    module Processor
+      def self.execute(model, grapho, data, user)
+        root_object = []
+        operations = []
+        data.each { |key, value| operations << Operation.new(model, key, value) }
+
+        operations.each do |operation|
+          item = operation.operand.precreate(operation.value)
+          root_object << item if item.present?
+        end
+
+        root_object = root_object.reduce(Hash.new, :merge)
+
+        fieldnames = Attribute.fieldnames_of(model)
+        root_object['created_by_id'] = user.id if fieldnames.include?('created_by_id')
+        root_object['updated_by_id'] = user.id if fieldnames.include?('updated_by_id')
+
+        sanitized = Attribute.correct(model, root_object)
+        root = model.create!(sanitized)
+
+        operations.each do |operation|
+          operation.operand.create(root, operation.value, grapho)
+        end
+
+        root.reload
+      end
+    end
+  end
+end

data/lib/graphoid/mutations/structure.rb

@@ -0,0 +1,9 @@
+module Graphoid
+  module Mutations
+    extend ActiveSupport::Concern
+
+    include Graphoid::Mutations::Create
+    include Graphoid::Mutations::Update
+    include Graphoid::Mutations::Delete
+  end
+end

data/lib/graphoid/mutations/update.rb

@@ -0,0 +1,55 @@
+module Graphoid
+  module Mutations
+    module Update
+      extend ActiveSupport::Concern
+
+      included do
+        Graphoid.initialize
+        model = self
+        grapho = Graphoid.build(model)
+        type = ::Types::MutationType
+
+        name = "update_#{grapho.name}"
+        plural = "update_many_#{grapho.plural}"
+
+        type.field name: name, type: grapho.type, null: true do
+          argument :id, GraphQL::Types::ID, required: true
+          argument :data, grapho.input, required: false
+        end
+
+        type.field name: plural, type: [grapho.type], null: true do
+          argument :where, grapho.filter, required: false
+          argument :data, grapho.input, required: false
+        end
+
+        type.class_eval do
+          define_method :"#{name}" do |id:, data: {}|
+            attrs = Utils.build_update_attributes(data, model, context)
+
+            begin
+              object = model.find(id)
+              object.update!(attrs)
+              object.reload
+            rescue Exception => ex
+              GraphQL::ExecutionError.new(ex.message)
+            end
+          end
+        end
+
+        type.class_eval do
+          define_method :"#{plural}" do |where: {}, data: {}|
+            attrs = Utils.build_update_attributes(data, model, context)
+
+            begin
+              objects = Graphoid::Queries::Processor.execute(model, where.to_h)
+              objects.update_all(attrs)
+              objects.all.to_a
+            rescue Exception => ex
+              GraphQL::ExecutionError.new(ex.message)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/graphoid/operators/attribute.rb

@@ -0,0 +1,64 @@
+module Graphoid
+  class Attribute
+    attr_reader :name, :type
+
+    PERMS = [:read, :create, :update, :delete]
+
+    def initialize(name:, type:)
+      @name = name.to_s
+      @camel_name = Utils.camelize(@name)
+      @type = type
+    end
+
+    def resolve(o)
+      Graphoid.driver.parse(o.operand, o.value, o.operator)
+    end
+
+    def embedded?
+      false
+    end
+
+    def relation?
+      false
+    end
+    
+    def precreate(value)
+      { self.name.to_sym => value }
+    end
+
+    def create(_,_,_)
+    end
+
+    class << self
+      def fields_of(model, action = :read)
+        fields = Graphoid.driver.fields_of(model) + graphields_of(model)
+        fields.select { |field| forbidden_fields_of(model, action).exclude?(field.name) }
+      end
+
+      def fieldnames_of(model, action = :read)
+        fields_of(model, action).map(&:name)
+      end
+
+      def graphields_of(model)
+        model.respond_to?(:graphields) ? model.send(:graphields) : []
+      end
+
+      def forbidden_fields_of(model, action)
+        skips = model.respond_to?(:forbidden_fields) ? model.send(:forbidden_fields) : []
+        skips.map do |field, actions|
+          field.to_s if actions.empty? || actions.include?(action)
+        end
+      end
+
+      def correct(model, attributes)
+        result = {}
+        fieldnames = fieldnames_of(model)
+        attributes.each do |key, value|
+          key = key.to_s.underscore if fieldnames.exclude?(key.to_s)
+          result[key] = value
+        end
+        result
+      end
+    end
+  end
+end

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

@@ -0,0 +1,15 @@
+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 }
+    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")
+    end
+  end
+end

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

@@ -0,0 +1,10 @@
+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)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,8 @@
+module Graphoid
+  class EmbedsOne < Relation
+    def create(parent, value, _)
+      attrs = Attribute.correct(self.klass, value)
+      parent.send(:"#{self.name}=", attrs)
+    end
+  end
+end

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

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

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

@@ -0,0 +1,16 @@
+module Graphoid
+  class HasOne < Relation
+    def create(parent, value, grapho)
+      attributes = Attribute.correct(self.klass, value)
+      attributes[:"#{grapho.name}_id"] = parent.id
+      self.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")
+    end
+  end
+end

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

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