graphql_includable 0.2.2 → 0.2.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 216d0034a2b3d1269aedfe519e49daa37d76295b
-  data.tar.gz: d75e50c2b1f403d68b96185e9016089b3524fde4
+  metadata.gz: 67916fbd68ce3698cbecbc818655408ba89f8f1a
+  data.tar.gz: 930edfc340b740528fd689b2bfd196f2f81aeef8
 SHA512:
-  metadata.gz: f02a18e427d3e3552d46e77d33837ba87d6af942899b3e8475cd45fffe932003145aa8dacb3fb9ff7378c737434e208a3f8af5c073abd106e0b5ec83020b9b1b
-  data.tar.gz: 63af52fe0be0ee1aeb1d8418597aa99c950bd25704c4d60c7f6d9a9b5a747b4e74d1f41287a821accc55b24a3cf35a34175ef4a86125e369a00df03c8b5cce20
+  metadata.gz: 48fe0a1f6e0bb028e7f643df33ecfcecec7701cfc382f33cb0928305a00fa6b6007e3e71ed5890be67b25d50c41079dfbfdbaece299c18e1c47f85ed116ad8a0
+  data.tar.gz: cd524919a412f7e98dff775b2b676d16c6fd30868c8f63f982c44e6a10110cd3cbb7dc2ecf93d0d91034561f3282b47a804e67afd3845cbc538e3c66891839f9

data/lib/graphql_includable/concern.rb

@@ -6,16 +6,18 @@ module GraphQLIncludable
 
     module ClassMethods
       def includes_from_graphql(ctx)
-        node = GraphQLIncludable::Concern.first_child_by_return_type(ctx.irep_node, model_name.to_s)
-        generated_includes = Concern.includes_from_graphql_node(node)
+        node = Resolver.find_node_by_return_type(ctx.irep_node, model_name)
+        generated_includes = Resolver.includes_for_node(node)
+        byebug if generated_includes == {}
         includes(generated_includes)
+      rescue => e
+        self
       end
 
       def delegate_cache
         @delegate_cache ||= {}
       end
 
-      # hook ActiveSupport's delegate method to track models and where their delegated methods go
       def delegate(*methods, args)
         methods.each do |method|
           delegate_cache[method] = args[:to]
@@ -23,154 +25,5 @@ module GraphQLIncludable
         super(*methods, args) if defined?(super)
       end
     end
-
-    def self.first_child_by_return_type(node, model_name)
-      matching_node = nil
-      return_type = node.return_type.unwrap
-      if return_type.to_s == model_name
-        matching_node = node
-      elsif node.respond_to?(:scoped_children)
-        node.scoped_children[return_type].each_value do |child_node|
-          matching_node = first_child_by_return_type(child_node, model_name)
-          break if matching_node
-        end
-      end
-      matching_node
-    end
-
-    def self.children_through_connection(node, return_model)
-      includes = {}
-      # if node_is_relay_connection?(node)
-      #   all_connection_children = node.scoped_children[node.return_type.unwrap]
-      #   connection_children = all_connection_children.except('edges')
-      #   edge_node = all_connection_children['edges']
-      #   all_edge_children = edge_node.scoped_children[edge_node.return_type.unwrap]
-      #   edge_children = all_edge_children.except('node')
-      #   target_node = all_edge_children['node']
-      #   children = target_node.scoped_children[target_node.return_type.unwrap]
-
-      #   target_association = return_model.reflect_on_association(node_return_class(target_node).name.underscore)
-      #   includes[target_association.name] = includes_from_graphql_node(target_node) if target_association
-      # else
-        children = node.scoped_children[node.return_type.unwrap]
-      # end
-
-      [children, includes]
-    end
-
-    def self.includes_from_graphql_node(node)
-      return_model = node_return_class(node)
-      return [] unless return_model
-
-      includes = []
-      children, nested_includes = children_through_connection(node, return_model)
-      children.each_value do |child_node|
-        child_includes = includes_from_graphql_child(child_node, return_model)
-
-        if child_includes.is_a?(Hash)
-          nested_includes.merge!(child_includes)
-        else
-          includes += child_includes.is_a?(Array) ? child_includes : [child_includes]
-        end
-      end
-
-      includes << nested_includes unless nested_includes.blank?
-      includes.uniq
-    end
-
-    def self.includes_from_graphql_child(child_node, return_model)
-      specified_includes = child_node.definitions[0].metadata[:includes]
-      attribute_name = node_predicted_association_name(child_node)
-      includes_chain = delegated_includes_chain(return_model, attribute_name)
-      association = get_model_association(return_model, attribute_name, includes_chain)
-
-      if association
-        child_includes = includes_from_graphql_node(child_node)
-        join_name = (specified_includes || attribute_name)
-
-        # if node_is_relay_connection?(child_node)
-        #   join_name = association.options[:through]
-        #   edge_includes_chain = [association.name]
-        #   edge_includes_chain << child_includes.pop[association.name.to_s.singularize.to_sym] if child_includes.last&.is_a?(Hash)
-        #   edge_includes = array_to_nested_hash(edge_includes_chain)
-        # end
-
-        includes_chain << join_name
-        includes_chain << child_includes unless child_includes.blank?
-        # byebug if node_is_relay_connection?(child_node)
-        edge_includes=nil
-        [edge_includes, array_to_nested_hash(includes_chain)].reject(&:blank?)
-      else
-        includes = []
-        includes << array_to_nested_hash(includes_chain) unless includes_chain.blank?
-        includes << specified_includes if specified_includes
-        includes
-      end
-    end
-
-    def self.node_return_class(node)
-      # rubocop:disable Lint/HandleExceptions, Style/RedundantBegin
-      begin
-        Object.const_get(node.return_type.unwrap.name.gsub(/(^SquareFoot|Edge$|Connection$)/, ''))
-      rescue NameError
-      end
-      # rubocop:enable Lint/HandleExceptions, Style/RedundantBegin
-    end
-
-    def self.node_is_relay_connection?(node)
-      node.return_type.unwrap.name =~ /Connection$/
-    end
-
-    def self.node_returns_active_record?(node)
-      klass = node_return_class(node)
-      klass && klass < ActiveRecord::Base
-    end
-
-    def self.node_predicted_association_name(node)
-      definition = node.definitions[0]
-      specified_includes = definition.metadata[:includes]
-      if specified_includes.is_a?(Symbol)
-        specified_includes
-      else
-        (definition.property || definition.name).to_sym
-      end
-    end
-
-    def self.get_model_association(model, association_name, includes_chain = nil)
-      delegated_model = model_name_to_class(includes_chain.last) unless includes_chain.blank?
-      (delegated_model || model).reflect_on_association(association_name)
-    end
-
-    # get a 1d array of the chain of delegated model names,
-    # so if model A delegates method B to model C, which delegates method B to model D,
-    # delegated_includes_chain(A, :B) => [:C, :D]
-    def self.delegated_includes_chain(base_model, method_name)
-      chain = []
-      method = method_name.to_sym
-      model_name = base_model.instance_variable_get('@delegate_cache').try(:[], method)
-      while model_name
-        chain << model_name
-        model = model_name_to_class(model_name)
-        model_name = model.instance_variable_get('@delegate_cache').try(:[], method)
-      end
-      chain
-    end
-
-    # convert a 1d array into a nested hash
-    # e.g. [:foo, :bar, :baz] => { :foo => { :bar => :baz }}
-    def self.array_to_nested_hash(arr)
-      arr.reverse.inject { |acc, item| { item => acc } }
-    end
-
-    # convert a model name into a class variable,
-    # e.g. :search_parameters -> SearchParameters
-    def self.model_name_to_class(model_name)
-      begin
-        model = model_name.to_s.camelize.constantize
-      rescue NameError
-        model = model_name.to_s.singularize.camelize.constantize
-      end
-      model
-    end
   end
 end

data/lib/graphql_includable/edge.rb

@@ -5,15 +5,17 @@ module GraphQLIncludable
       edge_class_name = join_chain.shift
       edge_class = str_to_class(edge_class_name)
 
-      root_node = { class_to_str(parent.class).to_s.singularize => parent }
-      terminal_node = { class_to_str(node.class).singularize => node }
+      root_association_key = class_to_str(parent.class).to_sym
+      root_node = { root_association_key => [parent] }
+      terminal_node = { class_to_str(node.class) => node }
       join_chain.reverse.each do |rel_name|
         terminal_node = { rel_name.to_s.pluralize => terminal_node }
       end
+
       search_hash = root_node.merge(terminal_node)
       edge_includes = join_chain.map { |s| s.to_s.singularize }
       edge_class = edge_class.includes(*edge_includes) unless edge_includes.empty?
-      @edge ||= edge_class.find_by(search_hash)
+      @edge ||= edge_class.joins(root_association_key).find_by(search_hash)
     end
 
     def method_missing(method_name, *args, &block)
@@ -36,21 +38,29 @@ module GraphQLIncludable
     end
 
     def class_to_str(klass)
-      klass.name.pluralize.downcase
+      klass.name.downcase
     end
 
     def joins_along_edge
-      join_chain = []
-      starting_class = parent.class
-      node_relationship_name = class_to_str(node.class)
-      while starting_class
-        reflection = starting_class.reflect_on_association(node_relationship_name)
-        association_name = reflection&.options&.try(:[], :through)
-        join_chain << association_name if association_name
-        starting_class = str_to_class(association_name)
-        node_relationship_name = node_relationship_name.singularize
+      edge_association_name = node.class.name.pluralize.downcase.to_sym
+      edge_association = parent.class.reflect_on_association(edge_association_name)
+      edge_joins = []
+      while edge_association.is_a? ActiveRecord::Reflection::ThroughReflection
+        edge_joins.unshift edge_association.options[:through]
+        edge_association = parent.class.reflect_on_association(edge_association.options[:through])
       end
-      join_chain
+      edge_joins
+      # join_chain = []
+      # starting_class = parent.class
+      # node_relationship_name = class_to_str(node.class)
+      # while starting_class
+      #   reflection = starting_class.reflect_on_association(node_relationship_name)
+      #   association_name = reflection&.options&.try(:[], :through)
+      #   join_chain << association_name if association_name
+      #   starting_class = str_to_class(association_name)
+      #   node_relationship_name = node_relationship_name.singularize
+      # end
+      # join_chain
     end
   end
 end

data/lib/graphql_includable.rb

@@ -1,4 +1,5 @@
 require 'graphql'
+require 'graphql_includable/resolver'
 require 'graphql_includable/concern'
 require 'graphql_includable/edge'
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: graphql_includable
 version: !ruby/object:Gem::Version
-  version: 0.2.2
+  version: 0.2.3
 platform: ruby
 authors:
 - Dan Rouse
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-03-02 00:00:00.000000000 Z
+date: 2018-04-09 00:00:00.000000000 Z
 dependencies: []
 description: 
 email:
@@ -42,7 +42,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.5.2
+rubygems_version: 2.6.11
 signing_key: 
 specification_version: 4
 summary: An ActiveSupport::Concern for GraphQL Ruby to eager-load query data