graphoid 0.0.1

data/lib/graphoid/operators/relation.rb

@@ -0,0 +1,70 @@
+module Graphoid
+
+  class Relation
+    attr_reader :name, :klass, :type, :inverse_name
+
+    def initialize(relation)
+      @name = relation.name.to_s
+      @camel_name = Utils.camelize(@name)
+      @inverse_name = Graphoid.driver.inverse_name_of(relation)
+      @klass = relation.class_name.constantize
+      @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|
+      type = :"#{type}?"
+      define_method type do
+        Graphoid.driver.send(type, @type)
+      end
+    end
+
+    def relation?
+      true
+    end
+
+    def one?
+      belongs_to? || has_one? || embeds_one?
+    end
+
+    def many?
+      # TODO: "through" can be one or many, we only support many at the moment.
+      has_many? || has_and_belongs_to_many? || through? || embeds_many?
+    end
+
+    def belongs?
+      belongs_to? || embedded_in?
+    end
+
+    def many_to_many?
+      has_and_belongs_to_many? || through?
+    end
+
+    def embedded?
+      embeds_one? || embeds_many? || embedded_in?
+    end
+
+    def precreate(_)
+    end
+    
+    def create(_,_,_)
+    end
+
+    def resolve(operation)
+      if one?
+        return operation.operand.exec(operation.scope, operation.value)
+      end
+
+      if many?
+        return Graphoid.driver.relate_many(o.scope, o.operand, o.value, o.operator)
+      end
+    end
+
+    class << self
+      def relations_of(model)
+        # return a list of relation objects
+        # Graphoid.driver.relations_of(model).map { |_, relation| Relation.new(relation) }
+        Graphoid.driver.relations_of(model)
+      end
+    end
+  end
+end

data/lib/graphoid/queries/operation.rb

@@ -0,0 +1,40 @@
+module Graphoid
+  class Operation
+    attr_reader :scope, :operand, :operator, :value
+
+    def initialize(scope, key, value)
+      @scope = scope
+      @operator = nil
+      @operand = key
+      @value = value
+
+      match = key.match(/^(.+)_(.+)$/)
+      @operand, @operator = match[1..2] if match
+      @operand = build_operand(@scope, @operand) || @operand
+    end
+
+    def resolve
+      @operand.resolve(self)
+    end
+
+    private
+
+    def build_operand(model, key)
+      fields = Attribute.fields_of(model)
+
+      field = fields.find { |f| f.name == key }
+      return Attribute.new(name: key, type: field.type) if field
+
+      field = fields.find { |f| f.name == key.underscore }
+      return Attribute.new(name: key.underscore, type: field.type) if field
+
+      relations = model.reflect_on_all_associations
+
+      relation = relations.find { |r| r.name == key.to_sym }
+      return Graphoid.driver.class_of(relation).new(relation) if relation
+
+      relation = relations.find { |r| r.name == key.underscore.to_sym }
+      return Graphoid.driver.class_of(relation).new(relation) if relation
+    end
+  end
+end

data/lib/graphoid/queries/processor.rb

@@ -0,0 +1,45 @@
+module Graphoid
+  module Queries
+    module Processor
+      class << self
+        def execute(scope, object)
+          object.each { |key, value| scope = process(scope, value, key) }
+          scope
+        end
+
+        def execute_array(scope, list, action)
+          if action == "OR"
+            scope = Graphoid.driver.execute_or(scope, list)
+          else
+            list.each { |object| scope = execute(scope, object) }
+          end
+          scope
+        end
+
+        def process(scope, value, key = nil)
+          if key && ["OR", "AND"].exclude?(key)
+            operation = Operation.new(scope, key, value)
+            filter = operation.resolve
+            return Graphoid.driver.execute_and(scope, filter)
+          end
+
+          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) 
+            end
+          end
+        end
+        
+        def children_of(selection)
+          selection.scoped_children.values[0]
+        end
+
+        def parse_order(scope, order)
+          fields = Attribute.fieldnames_of(scope)
+          Utils.underscore(order, fields)
+        end
+      end
+    end
+  end
+end

data/lib/graphoid/queries/queries.rb

@@ -0,0 +1,52 @@
+module Graphoid
+  module Queries
+    extend ActiveSupport::Concern
+
+    included do
+      Graphoid.initialize
+      model = self
+      grapho = Graphoid.build(model)
+      query_type = ::Types::QueryType
+
+      query_type.field name: grapho.name, type: grapho.type, null: true do
+        argument :id, GraphQL::Types::ID, required: false
+        argument :where, grapho.filter, required: false
+      end
+
+      query_type.field name: grapho.plural, type: [grapho.type], null: true do
+        Graphoid::Argument.query_many(self, grapho.filter, grapho.order, { required: false })
+      end
+
+      query_type.field name: "_#{grapho.plural}_meta", type: Graphoid::Types::Meta, null: true do
+        Graphoid::Argument.query_many(self, grapho.filter, grapho.order, { required: false })
+      end
+
+      query_type.class_eval do
+        define_method :"#{grapho.name}" do |id: nil, where: nil|
+          begin
+            return model.find(id) if id
+            Processor.execute(model, where.to_h).first
+          rescue Exception => ex
+            GraphQL::ExecutionError.new(ex.message)
+          end
+        end
+      end
+
+      query_type.class_eval do
+        define_method :"#{grapho.plural}" do |where: nil, order: nil, limit: nil, skip: nil|
+          begin
+            model = Graphoid.driver.eager_load(context.irep_node, model)
+            result = Processor.execute(model, where.to_h)
+            order = Processor.parse_order(model, order.to_h)
+            result = result.order(order).limit(limit)
+            Graphoid.driver.skip(result, skip)
+          rescue Exception => ex
+            GraphQL::ExecutionError.new(ex.message)
+          end
+        end
+
+        alias_method :"_#{grapho.plural}_meta", :"#{grapho.plural}"
+      end
+    end
+  end
+end

data/lib/graphoid/scalars.rb

@@ -0,0 +1,87 @@
+module Graphoid
+  module Upload
+  end
+
+  module Scalars
+    class << self
+      def generate
+        Graphoid::Scalars::DateTime ||= GraphQL::ScalarType.define do
+          name "DateTime"
+          description "DateTime ISO8601 formated"
+
+          coerce_input -> (value, _) do
+            begin
+              ::DateTime.iso8601(value)
+            rescue Exception => ex
+              GraphQL::ExecutionError.new(ex)
+            end
+          end
+        end
+
+        Graphoid::Scalars::Date ||= GraphQL::ScalarType.define do
+          name "Date"
+          description "Date ISO8601 formated"
+
+          coerce_input -> (value, _) do
+            begin
+              ::DateTime.iso8601(value)
+            rescue Exception => ex
+              GraphQL::ExecutionError.new(ex)
+            end
+          end
+        end
+
+        Graphoid::Scalars::Time ||= GraphQL::ScalarType.define do
+          name "Time"
+          description "Time ISO8601 formated"
+
+          coerce_input -> (value, _) do
+            begin
+              ::DateTime.iso8601(value)
+            rescue Exception => ex
+              GraphQL::ExecutionError.new(ex)
+            end
+          end
+        end
+
+        Graphoid::Scalars::Timestamp ||= GraphQL::ScalarType.define do
+          name "Timestamp"
+          description "Second elapsed since 1970-01-01"
+
+          coerce_input -> (value, _) do
+            begin
+              ::DateTime.iso8601(value)
+            rescue Exception => ex
+              GraphQL::ExecutionError.new(ex)
+            end
+          end
+        end
+
+        Graphoid::Scalars::Text ||= GraphQL::ScalarType.define do
+          name "Text"
+          description "Should be string? explain this please."
+        end
+
+        Graphoid::Scalars::BigInt ||= GraphQL::ScalarType.define do
+          name "BigInt"
+          description "WTF ??"
+        end
+
+        Graphoid::Scalars::Decimal ||= GraphQL::ScalarType.define do
+          name "Decimal"
+          description "Define pliiiizzzzzzz"
+        end
+
+        Graphoid::Scalars::Hash ||= GraphQL::ScalarType.define do
+          name "Hash"
+          description "Hash scalar"
+        end
+
+        Graphoid::Scalars::Array ||= GraphQL::ScalarType.define do
+          name "Array"
+          description "Array scalar"
+        end
+      end
+    end
+  end
+end

data/lib/graphoid/utils.rb

@@ -0,0 +1,39 @@
+module Graphoid
+  module Utils
+    class << self
+      def modelize text
+        graphqlize text.to_s.capitalize.camelize
+      end
+
+      def camelize text
+        # we are doing it twice because _id gets translated to Id the first time and to id the second time.
+        graphqlize text.to_s.camelize(:lower).camelize(:lower)
+      end
+
+      def graphqlize text
+        text.to_s.gsub(/::/, '_')
+      end
+
+      def symbolize(fields)
+        fields.keys.map(&:underscore).map(&:to_sym)
+      end
+
+      def underscore props, fields = []
+        attrs = {}
+        props.each do |key, value|
+          key = key.underscore if fields.exclude?(key)
+          attrs[key] = value
+        end
+        attrs
+      end
+
+      def build_update_attributes(data, model, context)
+        user = context[:current_user]
+        fields = Graphoid::Attribute.fieldnames_of(model)
+        attrs = underscore(data, fields)
+        attrs['updated_by_id'] = user.id if user && fields.include?('updated_by_id')
+        attrs
+      end
+    end
+  end
+end

data/lib/graphoid/version.rb

@@ -0,0 +1,3 @@
+module Graphoid
+  VERSION = '0.0.1'
+end

data/lib/graphoid.rb

@@ -0,0 +1,36 @@
+require 'graphoid/utils'
+require 'graphoid/grapho'
+require 'graphoid/mapper'
+require 'graphoid/config'
+require 'graphoid/scalars'
+require 'graphoid/argument'
+require 'graphoid/graphield'
+
+require 'graphoid/operators/attribute'
+require 'graphoid/operators/relation'
+require 'graphoid/operators/inherited/belongs_to'
+require 'graphoid/operators/inherited/embeds_one'
+require 'graphoid/operators/inherited/embeds_many'
+require 'graphoid/operators/inherited/has_many'
+require 'graphoid/operators/inherited/has_one'
+require 'graphoid/operators/inherited/many_to_many'
+
+require 'graphoid/queries/queries'
+require 'graphoid/queries/processor'
+require 'graphoid/queries/operation'
+
+require 'graphoid/mutations/create'
+require 'graphoid/mutations/update'
+require 'graphoid/mutations/delete'
+require 'graphoid/mutations/processor'
+require 'graphoid/mutations/structure'
+
+require 'graphoid/drivers/mongoid'
+require 'graphoid/drivers/active_record'
+
+require 'graphoid/definitions/types'
+require 'graphoid/definitions/orders'
+require 'graphoid/definitions/filters'
+require 'graphoid/definitions/inputs'
+
+require 'graphoid/main'

metadata

@@ -0,0 +1,120 @@
+--- !ruby/object:Gem::Specification
+name: graphoid
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Maximiliano Perez Coto
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2019-04-06 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 5.1.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 5.1.0
+- !ruby/object:Gem::Dependency
+  name: sqlite3
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec-collection_matchers
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: A gem that helps you autogenerate a GraphQL api from MongoId models.
+email:
+- maxiperezc@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- MIT-LICENSE
+- README.md
+- Rakefile
+- lib/graphoid.rb
+- lib/graphoid/argument.rb
+- lib/graphoid/config.rb
+- lib/graphoid/definitions/filters.rb
+- lib/graphoid/definitions/inputs.rb
+- lib/graphoid/definitions/orders.rb
+- lib/graphoid/definitions/types.rb
+- lib/graphoid/drivers/active_record.rb
+- lib/graphoid/drivers/mongoid.rb
+- lib/graphoid/graphield.rb
+- lib/graphoid/grapho.rb
+- lib/graphoid/main.rb
+- lib/graphoid/mapper.rb
+- lib/graphoid/mutations/create.rb
+- lib/graphoid/mutations/delete.rb
+- lib/graphoid/mutations/processor.rb
+- lib/graphoid/mutations/structure.rb
+- lib/graphoid/mutations/update.rb
+- lib/graphoid/operators/attribute.rb
+- lib/graphoid/operators/inherited/belongs_to.rb
+- lib/graphoid/operators/inherited/embeds_many.rb
+- lib/graphoid/operators/inherited/embeds_one.rb
+- lib/graphoid/operators/inherited/has_many.rb
+- lib/graphoid/operators/inherited/has_one.rb
+- lib/graphoid/operators/inherited/many_to_many.rb
+- lib/graphoid/operators/relation.rb
+- lib/graphoid/queries/operation.rb
+- lib/graphoid/queries/processor.rb
+- lib/graphoid/queries/queries.rb
+- lib/graphoid/scalars.rb
+- lib/graphoid/utils.rb
+- lib/graphoid/version.rb
+homepage: http://www.github.com/maxiperezc/graphoid
+licenses:
+- MIT
+metadata: {}
+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: []
+rubygems_version: 3.0.3
+signing_key: 
+specification_version: 4
+summary: Generate GraphQL from ActiveRecord or Mongoid
+test_files: []