graphoid 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 570048f8ac7a5863e2649feabf58df51352c8736a8d94f8009ce666d26f21e67
+  data.tar.gz: 3168975860650e784303f5cc57851b4ed7106e360dc55af30077f02c4c0a6f1a
+SHA512:
+  metadata.gz: 3e8eae2534153a462a4a705ddf43176146b5042d64d812f5dd62d246bba0dfece3f306539f6e19eba33329e81e7aabb95d07ceecd21e0ecca419e347c2314963
+  data.tar.gz: cc0450a2be3f570fca4178aaf969ebf93aa3c981faf2ce43bdf6e079193c1c62bf8e3e38d77eda5d6ae64e271f3c7bacd9bc735256497e15879fcf1a5cee7afb

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright 2018 
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,62 @@
+# Graphoid
+This gem is used to generate a full GraphQL api using introspection of MongoId models.
+
+## Dependency
+This gem depends on the graphql gem for rails https://github.com/rmosolgo/graphql-ruby
+So it is required to have it and install it using
+```bash
+rails generate graphql:install
+```
+
+## Usage
+Require all the models in which you want to have basic find one, find many, create, update and delete actions on.
+
+Create the file `config/initializers/Graphoid.rb`
+
+And require the models like this:
+
+```ruby
+Graphoid.configure do |config|
+  config.driver = :mongoid
+  config.driver = :active_record
+end
+Graphoid.initialize
+```
+
+## Installation
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'graphoid'
+```
+
+And then execute:
+```bash
+$ bundle
+```
+
+Or install it yourself as:
+```bash
+$ gem install graphoid
+```
+
+Then you can determine which queries and mutations should be created in `app/graphql/types/query_type.rb`
+
+```ruby
+include Graphoid::Queries
+include Graphoid::Mutations
+```
+
+And which mutations should be created in `app/graphql/types/mutation_type.rb`
+
+```ruby
+include Graphoid::Graphield
+```
+
+## Contributing
+Figure out the driver
+Functionality to sort top level models by association values
+Filter by Array or Hash => The cases are failing, implementation correction needed.
+
+## License
+The gem is available as open source under the terms of the [MIT License](http://opensource.org/licenses/MIT).

data/Rakefile

@@ -0,0 +1,33 @@
+begin
+  require 'bundler/setup'
+rescue LoadError
+  puts 'You must `gem install bundler` and `bundle install` to run rake tasks'
+end
+
+require 'rdoc/task'
+
+RDoc::Task.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = 'Graphoid'
+  rdoc.options << '--line-numbers'
+  rdoc.rdoc_files.include('README.md')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+
+
+
+
+
+require 'bundler/gem_tasks'
+
+require 'rake/testtask'
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'test'
+  t.pattern = 'test/**/*_test.rb'
+  t.verbose = false
+end
+
+
+task default: :test

data/lib/graphoid/argument.rb

@@ -0,0 +1,12 @@
+module Graphoid
+  module Argument
+    class << self
+      def query_many(field, filter, order, required = {})
+        field.argument :where, filter, required
+        field.argument :order, order, required
+        field.argument :limit, GraphQL::Types::Int, required
+        field.argument :skip,  GraphQL::Types::Int, required
+      end
+    end
+  end
+end

data/lib/graphoid/config.rb

@@ -0,0 +1,19 @@
+module Graphoid
+  class << self
+    attr_accessor :configuration
+
+    def configure
+      self.configuration ||= Configuration.new
+      yield(configuration)
+      Graphoid.initialize
+    end
+  end
+
+  class Configuration
+    attr_accessor :driver
+
+    def initialize
+      @driver = :active_record
+    end
+  end
+end

data/lib/graphoid/definitions/filters.rb

@@ -0,0 +1,57 @@
+module Graphoid
+  module Filters
+
+    LIST = {}
+
+    class << self
+      def generate(model)
+        LIST[model] ||= GraphQL::InputObjectType.define do
+          name("#{Utils.graphqlize(model.name)}Filter")
+          description("Generated model filter for #{model.name}")
+
+          Attribute.fields_of(model).each do |field|
+            type = Graphoid::Mapper.convert(field)
+            name = Utils.camelize(field.name)
+
+            argument name, type
+
+            m = LIST[model]
+            argument(:OR,  -> { types[m] })
+            argument(:AND, -> { types[m] })
+
+            operators = ["lt", "lte", "gt", "gte", "contains", "not"]
+            operators.push("regex") if Graphoid.configuration.driver == :mongoid
+
+            operators.each do |suffix|
+              argument "#{name}_#{suffix}", type
+            end
+
+            ["in", "nin"].each do |suffix|
+              argument "#{name}_#{suffix}", types[type]
+            end
+          end
+
+          Relation.relations_of(model).each do |name, relation|
+            relation_class = relation.class_name.safe_constantize
+            next unless relation_class
+
+            relation_filter = LIST[relation_class]
+            next unless relation_filter
+
+            relation_name = Utils.camelize(name)
+
+            if Relation.new(relation).many?
+              ["some", "none", "every"].each do |suffix|
+                argument "#{relation_name}_#{suffix}", relation_filter
+              end
+            else
+              argument "#{relation_name}", relation_filter
+            end
+          end
+
+        end
+      end
+
+    end
+  end
+end

data/lib/graphoid/definitions/inputs.rb

@@ -0,0 +1,41 @@
+module Graphoid
+  module Inputs
+    LIST = {}
+
+    class << self
+      def generate model
+        LIST[model] ||= GraphQL::InputObjectType.define do
+          name = Utils.graphqlize(model.name)
+          name("#{name}Input")
+          description("Generated model input for #{name}")
+
+          Attribute.fields_of(model).each do |field|
+            unless field.name.start_with?("_")
+              type = Graphoid::Mapper.convert(field)
+              name = Utils.camelize(field.name)
+
+              argument(name, type)
+            end
+          end
+
+          Relation.relations_of(model).each do |name, relation|
+            relation_class = relation.class_name.safe_constantize
+            next unless relation_class
+
+            relation_input = LIST[relation_class]
+            next unless relation_input
+
+            name = Utils.camelize(relation.name)
+
+            r = Relation.new(relation)
+            if r.many?
+              argument(name, -> { types[relation_input] })
+            else
+              argument(name, -> { relation_input })
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/graphoid/definitions/orders.rb

@@ -0,0 +1,43 @@
+module Graphoid
+  module Orders
+
+    LIST = {}
+    @@enum_type = nil
+
+    class << self
+      def generate(model)
+        LIST[model] ||= GraphQL::InputObjectType.define do
+          name("#{Utils.graphqlize(model.name)}Order")
+          description("Generated model order for #{model.name}")
+
+          Attribute.fields_of(model).each do |field|
+            name = Utils.camelize(field.name)
+            argument(name, Orders.enum_type)
+          end
+
+          Relation.relations_of(model).each do |name, relation|
+            relation_class = relation.class_name.safe_constantize
+            next unless relation_class
+
+            relation_order = LIST[relation_class]
+            next unless relation_order
+
+            relation_name = Utils.camelize(name)
+
+            argument(relation_name, relation_order)
+          end
+        end
+      end
+
+      def enum_type
+        @@enum_type ||= GraphQL::EnumType.define do
+          name "SortType"
+
+          value "ASC", "Ascendent"
+          value "DESC", "Descendent"
+        end
+      end
+    end
+  end
+
+end

data/lib/graphoid/definitions/types.rb

@@ -0,0 +1,119 @@
+module Graphoid
+  module Types
+
+    LIST = {}
+    ENUMS = {}
+
+    class << self
+      def generate(model)
+        Graphoid::Types::Meta ||= GraphQL::ObjectType.define do
+          name("Meta")
+          description("Meta Type")
+          field("count", types.Int)
+        end
+
+        LIST[model] ||= GraphQL::ObjectType.define do
+          name = Utils.graphqlize(model.name)
+          name("#{name}Type")
+          description("Generated model type for #{name}")
+
+          Attribute.fields_of(model).each do |_field|
+            type = Graphoid::Mapper.convert(_field)
+            name = Utils.camelize(_field.name)
+            field(name, type)
+
+            model.class_eval do
+              if _field.name.include?('_')
+                define_method :"#{Utils.camelize(_field.name)}" do
+                  method_name = _field.name.to_s
+                  self[method_name] || self.send(method_name)
+                end
+              end
+            end
+          end
+
+          Relation.relations_of(model).each do |name, relation|
+            relation_class = relation.class_name.safe_constantize
+
+            message = "in model #{model.name}: skipping relation #{relation.class_name}"
+            unless relation_class
+              STDERR.puts "Graphoid: warning: #{message} because the model name is not valid" if ENV['DEBUG']
+              next
+            end
+
+            relation_type = LIST[relation_class]
+            unless relation_type
+              STDERR.puts "Graphoid: warning: #{message} because it was not found as a model" if ENV['DEBUG']
+              next
+            end
+
+            name = Utils.camelize(relation.name)
+
+            model.class_eval do
+              if relation.name.to_s.include?('_')
+                define_method :"#{name}" do
+                  self.send(relation.name)
+                end
+              end
+            end
+
+            if relation_type
+              filter = Graphoid::Filters::LIST[relation_class]
+              order  = Graphoid::Orders::LIST[relation_class]
+
+              if Relation.new(relation).many?
+                plural_name = name.pluralize
+
+                field plural_name, types[relation_type] do
+                  Graphoid::Argument.query_many(self, filter, order)
+                  Graphoid::Types.resolve_many(self, relation_class, relation)
+                end
+
+                field "_#{plural_name}_meta", Graphoid::Types::Meta do
+                  Graphoid::Argument.query_many(self, filter, order)
+                  Graphoid::Types.resolve_many(self, relation_class, relation)
+                end
+              else
+                field name, relation_type do
+                  argument :where, filter
+                  Graphoid::Types.resolve_one(self, relation_class, relation)
+                end
+              end
+            end
+          end
+        end
+      end
+
+      def resolve_one(field, model, association)
+        field.resolve -> (obj, args, ctx) do
+          filter = args["where"].to_h
+          result = obj.send(association.name)
+          result = Graphoid::Queries::Processor.execute(model.where({ id: result.id }), filter).first if filter.present? && result
+          result
+        end
+      end
+
+      def resolve_many(field, model, association)
+        field.resolve -> (obj, args, ctx) do
+          filter = args["where"].to_h
+          order = args["order"].to_h
+          limit = args["limit"]
+          skip = args["skip"]
+
+          result = obj.send(association.name)
+          result = Graphoid::Queries::Processor.execute(result, filter) if filter.present?
+
+          if order.present?
+            order = Graphoid::Queries::Processor.parse_order(obj.send(association.name), order)
+            result = result.order(order)
+          end
+
+          result = result.limit(limit) if limit.present?
+          result = result.skip(skip) if skip.present?
+
+          result
+        end
+      end
+    end
+  end
+end

data/lib/graphoid/drivers/active_record.rb

@@ -0,0 +1,187 @@
+module Graphoid
+  module ActiveRecordDriver
+    class << self
+      def through?(type)
+        type == ActiveRecord::Reflection::ThroughReflection
+      end
+
+      def has_and_belongs_to_many?(type)
+        type == ActiveRecord::Reflection::HasAndBelongsToManyReflection
+      end
+
+      def has_many?(type)
+        type == ActiveRecord::Reflection::HasManyReflection
+      end
+
+      def belongs_to?(type)
+        type == ActiveRecord::Reflection::BelongsToReflection
+      end
+
+      def has_one?(type)
+        type == ActiveRecord::Reflection::HasOneReflection
+      end
+
+      def embeds_one?(type)
+        false
+      end
+
+      def embeds_many?(type)
+        false
+      end
+
+      def embedded_in?(type)
+        false
+      end
+
+      def types_map
+        {
+          binary:  GraphQL::Types::Boolean,
+          boolean: GraphQL::Types::Boolean,
+          float:   GraphQL::Types::Float,
+          integer: GraphQL::Types::Int,
+          string:  GraphQL::Types::String,
+
+          datetime:   Graphoid::Scalars::DateTime,
+          date:       Graphoid::Scalars::DateTime,
+          time:       Graphoid::Scalars::DateTime,
+          timestamp:  Graphoid::Scalars::DateTime,
+          text:       Graphoid::Scalars::Text,
+          bigint:     Graphoid::Scalars::BigInt,
+          decimal:    Graphoid::Scalars::Decimal
+        }
+      end
+
+      def class_of(relation)
+        {
+          ActiveRecord::Reflection::HasAndBelongsToManyReflection => ManyToMany,
+          ActiveRecord::Reflection::BelongsToReflection => BelongsTo,
+          ActiveRecord::Reflection::ThroughReflection => ManyToMany,
+          ActiveRecord::Reflection::HasManyReflection => HasMany,
+          ActiveRecord::Reflection::HasOneReflection => HasOne
+        }[relation.class] || Relation
+      end
+
+      def inverse_name_of(relation)
+        relation.inverse_of&.class_name&.underscore
+      end
+
+      def fields_of(model)
+        model.columns
+      end
+
+      def relations_of(model)
+        model.reflections
+      end
+
+      def skip(result, skip)
+        result.offset(skip)
+      end
+
+      def relation_type(relation)
+        relation.class
+      end
+
+      def eager_load(_selection, model)
+        model
+      end
+
+      def execute_and(scope, parsed)
+        scope.where(parsed)
+      end
+
+      def execute_or(scope, list)
+        list.map! do |object|
+          Graphoid::Queries::Processor.execute(scope, object)
+        end
+        list.reduce(:or)
+      end
+
+      def parse(attribute, value, operator)
+        field = attribute.name
+        case operator
+        when "not"
+          parsed = *["#{field} != ?", value]
+          parsed = *["#{field} not like ?", "#{value}"] if attribute.type == :string
+          parsed = *["#{field} is not null"] if value.nil?
+        when "contains", "regex"
+          parsed = *["#{field} like ?", "%#{value}%"]
+        when "gt", "gte", "lt", "lte", "not", "in", "nin"
+          operator = { gt: ">", gte: ">=", lt: "<", lte: "<=", in: "in", nin: "not in" }[operator.to_sym]
+          parsed = *["#{field} #{operator} (?)", value]
+        else
+          parsed = *["#{field} = ?", value]
+        end
+        parsed
+      end
+
+      # TODO: fix this as it is unused
+      def relate_through(scope, relation, value)
+        # if relation.has_one_through?
+        #   ids = Graphoid::Queries::Processor.execute(relation.klass, value).to_a.map(&:id)
+        #   through = relation.source.options[:through].to_s.camelize.constantize
+        #   ids = through.where(id: ids)
+        #   ids = Graphoid::Queries::Processor.execute(relation.klass, value).to_a.map(&:id)
+        #   parsed = *["#{field.underscore}_id in (?)", ids]
+        # end
+      end
+
+      def relate_many(scope, relation, value, operator)
+        parsed = {}
+        field_name = relation.inverse_name || scope.name.underscore
+        target = Graphoid::Queries::Processor.execute(relation.klass, value).to_a
+
+        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}_id"
+          ids = target.map(&(field_name))
+        end
+
+        if operator == "none"
+          parsed = *["id not in (?)", ids] if ids.present?
+        elsif operator == "some"
+          parsed = *["id in (?)", ids]
+        elsif operator == "every"
+
+          # the following process is a SQL division
+          # the amount of queries it executes is on per row
+          # it is the same than doing an iteration process
+          # that iteration process would work in mongoid too
+
+          # TODO: check and fix this query for many to many relations
+
+          plural_name = relation.name.pluralize
+          conditions = value.map do |_key, _value|
+            operation = Operation.new(relation.klass, _key, _value)
+            parsed = parse(operation.operand, operation.value, operation.operator)
+            val = parsed.last.is_a?(String) ? "'#{parsed.last}'" : parsed.last
+            parsed = parsed.first.sub("?", val)
+            " AND #{parsed}"
+          end.join
+
+          query = "
+                    SELECT count(id) as total, #{field_name}
+                    FROM #{plural_name} A
+                    GROUP BY #{field_name}
+                    HAVING total = (
+                      SELECT count(id)
+                      FROM #{plural_name} B
+                      WHERE B.#{field_name} = A.#{field_name}
+                      #{conditions}
+                    )
+                  "
+          result = ActiveRecord::Base.connection.execute(query)
+          ids = result.map{ |row| row["#{field_name}"] }
+
+          parsed = *["id in (?)", ids]
+        end
+
+        parsed
+      end
+    end
+
+  end
+
+end