graphoid 0.0.2 → 0.0.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5f060ce3dc46c8bf367aeec184daa225ebbe3d33471a37492f668b61a917e23d
-  data.tar.gz: a62c8e9a0abd9c10b0a8842bdb5ca75a8cf8050fba088db794f723376a966f27
+  metadata.gz: 991348c4876e83ff75d3416a84f61cb1cd7d12773efb2cdeff71866ca16174ed
+  data.tar.gz: 95337e84c31b8e0feded9ab67fc7291d8e0269590602975c37473015aa19f182
 SHA512:
-  metadata.gz: d183869e672db7ccb37a72e9c3fea49db92add12130e4a59c1e1cfa3f69d04db60fcad8141e99f0b8167ab2b3eb068eefde7c768be71e096001fd5117af7f470
-  data.tar.gz: f5f2fa9be4b6052c10b036f9b5bc2f9c9dd59025b14aa2ecdf09c9885072686b3ebe09442dd47daf842c888a7323c4c52ce2b2717acad15f136e0544af9bb4be
+  metadata.gz: 5cdf65fa4c22ac0a01ec2671152886c4335940aeebf729a60bb83fc0445af18902f1c1c9e79cf5bfb0bb097778b38baeac09aa2c1ae2dc8429ea2bc8f8efd3f1
+  data.tar.gz: 9522be43b81979348c9ebfc2a319d62d7fc7343b2c66db8bccc04ee7549fa6fa309aa1b63317d7ccfff0bc81634dddf1a3dc826777cc05f6c5b938202c02c7c0

data/README.md

@@ -1,62 +1,76 @@
 # Graphoid
-This gem is used to generate a full GraphQL api using introspection of MongoId models.
+This gem is used to generate a full GraphQL API using introspection of Mongoid or ActiveRecord models.
+After installing it, you will have create, update, delete, and query actions on any rails models you want.
 
 ## 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
-```
+So please install that gem first before continuing
 
-## Usage
-Require all the models in which you want to have basic find one, find many, create, update and delete actions on.
+## Installation
+Add this line to your Gemfile:
+
+```ruby
+gem 'graphoid'
+```
 
-Create the file `config/initializers/Graphoid.rb`
+```bash
+$ bundle install
+```
 
-And require the models like this:
+## Configuration
+Create the file `config/initializers/graphoid.rb`
+And configure the database you want to use in it.
 
 ```ruby
 Graphoid.configure do |config|
   config.driver = :mongoid
+  # or
   config.driver = :active_record
 end
-Graphoid.initialize
 ```
 
-## Installation
-Add this line to your application's Gemfile:
+## Usage
+You can determine which models will be visible in the API by including the Graphoid Queries and Mutations
 
 ```ruby
-gem 'graphoid'
-```
-
-And then execute:
-```bash
-$ bundle
-```
-
-Or install it yourself as:
-```bash
-$ gem install graphoid
+class Person
+  include Graphoid::Queries
+  include Graphoid::Mutations
+end
 ```
 
-Then you can determine which queries and mutations should be created in `app/graphql/types/query_type.rb`
-
+You can also include a special concern that will let you create virtual fields and forbid access to existing fields
 ```ruby
-include Graphoid::Queries
-include Graphoid::Mutations
-```
+class Person
+  include Graphoid::Graphield
 
-And which mutations should be created in `app/graphql/types/mutation_type.rb`
+  graphield :full_name, String # virtual fields need to resolve as a method
+  graphorbid :balance # attribute balance will not be exposed in the API
 
-```ruby
-include Graphoid::Graphield
+  def full_name
+    "#{first_name} #{last_name}"
+  end
+end
 ```
 
 ## 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.
+Revise TODOs in the code
+Make a tutorial video
+Fix Rubocop errors
+Live Reload
+AR eager load
+Relation with aliases tests
+Aggregations
+Remove config / auto-setup AR-Mongo
+Write division for "every" in Mongoid and AR
+Permissions on fields
+has_one_through implementation
+has_many_selves (employee) tests
+has_and_belongs_to_many_selves (followers) tests
+Embedded::Many filtering implementation
+Embedded::One filtering with OR/AND
 
 ## License
 The gem is available as open source under the terms of the [MIT License](http://opensource.org/licenses/MIT).

data/Rakefile

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 begin
   require 'bundler/setup'
 rescue LoadError
@@ -14,11 +16,6 @@ RDoc::Task.new(:rdoc) do |rdoc|
   rdoc.rdoc_files.include('lib/**/*.rb')
 end
 
-
-
-
-
-
 require 'bundler/gem_tasks'
 
 require 'rake/testtask'
@@ -29,5 +26,4 @@ Rake::TestTask.new(:test) do |t|
   t.verbose = false
 end
 
-
 task default: :test

data/lib/graphoid/argument.rb

@@ -1,4 +1,7 @@
+# frozen_string_literal: true
+
 module Graphoid
+  # A module that defines the query packet arguments
   module Argument
     class << self
       def query_many(field, filter, order, required = {})

data/lib/graphoid/config.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Graphoid
   class << self
     attr_accessor :configuration

data/lib/graphoid/definitions/filters.rb

@@ -1,6 +1,7 @@
+# frozen_string_literal: true
+
 module Graphoid
   module Filters
-
     LIST = {}
 
     class << self
@@ -19,14 +20,14 @@ module Graphoid
             argument(:OR,  -> { types[m] })
             argument(:AND, -> { types[m] })
 
-            operators = ["lt", "lte", "gt", "gte", "contains", "not"]
-            operators.push("regex") if Graphoid.configuration.driver == :mongoid
+            operators = %w[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|
+            %w[in nin].each do |suffix|
               argument "#{name}_#{suffix}", types[type]
             end
           end
@@ -41,17 +42,15 @@ module Graphoid
             relation_name = Utils.camelize(name)
 
             if Relation.new(relation).many?
-              ["some", "none", "every"].each do |suffix|
+              %w[some none every].each do |suffix|
                 argument "#{relation_name}_#{suffix}", relation_filter
               end
             else
-              argument "#{relation_name}", relation_filter
+              argument relation_name.to_s, relation_filter
             end
           end
-
         end
       end
-
     end
   end
 end

data/lib/graphoid/definitions/inputs.rb

@@ -1,21 +1,23 @@
+# frozen_string_literal: true
+
 module Graphoid
   module Inputs
     LIST = {}
 
     class << self
-      def generate model
+      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)
+            next if field.name.start_with?('_')
 
-              argument(name, type)
-            end
+            type = Graphoid::Mapper.convert(field)
+            name = Utils.camelize(field.name)
+
+            argument(name, type)
           end
 
           Relation.relations_of(model).each do |name, relation|

data/lib/graphoid/definitions/orders.rb

@@ -1,6 +1,7 @@
+# frozen_string_literal: true
+
 module Graphoid
   module Orders
-
     LIST = {}
     @@enum_type = nil
 
@@ -31,13 +32,12 @@ module Graphoid
 
       def enum_type
         @@enum_type ||= GraphQL::EnumType.define do
-          name "SortType"
+          name 'OrderType'
 
-          value "ASC", "Ascendent"
-          value "DESC", "Descendent"
+          value 'ASC', 'Ascendent'
+          value 'DESC', 'Descendent'
         end
       end
     end
   end
-
 end

data/lib/graphoid/definitions/types.rb

@@ -1,15 +1,16 @@
+# frozen_string_literal: true
+
 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)
+          name('Meta')
+          description('Meta Type')
+          field('count', types.Int)
         end
 
         LIST[model] ||= GraphQL::ObjectType.define do
@@ -26,24 +27,24 @@ module Graphoid
               if _field.name.include?('_')
                 define_method :"#{Utils.camelize(_field.name)}" do
                   method_name = _field.name.to_s
-                  self[method_name] || self.send(method_name)
+                  self[method_name] || send(method_name)
                 end
               end
             end
           end
 
-          Relation.relations_of(model).each do |name, relation|
+          Relation.relations_of(model).each do |_, 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']
+              warn "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']
+              warn "Graphoid: warning: #{message} because it was not found as a model" if ENV['DEBUG']
               next
             end
 
@@ -52,32 +53,32 @@ module Graphoid
             model.class_eval do
               if relation.name.to_s.include?('_')
                 define_method :"#{name}" do
-                  self.send(relation.name)
+                  send(relation.name)
                 end
               end
             end
 
-            if relation_type
-              filter = Graphoid::Filters::LIST[relation_class]
-              order  = Graphoid::Orders::LIST[relation_class]
+            next unless relation_type
 
-              if Relation.new(relation).many?
-                plural_name = name.pluralize
+            filter = Graphoid::Filters::LIST[relation_class]
+            order  = Graphoid::Orders::LIST[relation_class]
 
-                field plural_name, types[relation_type] do
-                  Graphoid::Argument.query_many(self, filter, order)
-                  Graphoid::Types.resolve_many(self, relation_class, relation)
-                end
+            if Relation.new(relation).many?
+              plural_name = name.pluralize
 
-                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
+              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
@@ -85,26 +86,31 @@ module Graphoid
       end
 
       def resolve_one(field, model, association)
-        field.resolve -> (obj, args, ctx) do
-          filter = args["where"].to_h
+        field.resolve lambda { |obj, args, _ctx|
+          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
+          processor = Graphoid::Queries::Processor
+          if filter.present? && result
+            result = processor.execute(model.where(id: result.id), filter).first
+          end
           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"]
+      def resolve_many(field, _model, association)
+        field.resolve lambda { |obj, args, _ctx|
+          filter = args['where'].to_h
+          order = args['order'].to_h
+          limit = args['limit']
+          skip = args['skip']
+
+          processor = Graphoid::Queries::Processor
 
           result = obj.send(association.name)
-          result = Graphoid::Queries::Processor.execute(result, filter) if filter.present?
+          result = processor.execute(result, filter) if filter.present?
 
           if order.present?
-            order = Graphoid::Queries::Processor.parse_order(obj.send(association.name), order)
+            order = processor.parse_order(obj.send(association.name), order)
             result = result.order(order)
           end
 
@@ -112,7 +118,7 @@ module Graphoid
           result = result.skip(skip) if skip.present?
 
           result
-        end
+        }
       end
     end
   end

data/lib/graphoid/drivers/active_record.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Graphoid
   module ActiveRecordDriver
     class << self
@@ -21,33 +23,33 @@ module Graphoid
         type == ActiveRecord::Reflection::HasOneReflection
       end
 
-      def embeds_one?(type)
+      def embeds_one?(_type)
         false
       end
 
-      def embeds_many?(type)
+      def embeds_many?(_type)
         false
       end
 
-      def embedded_in?(type)
+      def embedded_in?(_type)
         false
       end
 
       def types_map
         {
-          binary:  GraphQL::Types::Boolean,
+          binary: GraphQL::Types::Boolean,
           boolean: GraphQL::Types::Boolean,
-          float:   GraphQL::Types::Float,
+          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
+          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
 
@@ -99,17 +101,17 @@ module Graphoid
       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]
+        when 'not'
+          parsed = ["#{field} != ?", value]
+          parsed = ["#{field} not like ?", value.to_s] 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]
+          parsed = ["#{field} = ?", value]
         end
         parsed
       end
@@ -131,19 +133,19 @@ module Graphoid
         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))
+          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))
+          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"
+        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
@@ -157,7 +159,7 @@ module Graphoid
             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)
+            parsed = parsed.first.sub('?', val)
             " AND #{parsed}"
           end.join
 
@@ -173,15 +175,13 @@ module Graphoid
                     )
                   "
           result = ActiveRecord::Base.connection.execute(query)
-          ids = result.map{ |row| row["#{field_name}"] }
+          ids = result.map { |row| row[field_name.to_s] }
 
-          parsed = *["id in (?)", ids]
+          parsed = ['id in (?)', ids]
         end
 
         parsed
       end
     end
-
   end
-
 end