graphql_includable 0.2.6 → 0.2.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 3c8f20574657c12b74d55fe9a06509381ff8f424
-  data.tar.gz: b4c9667c907560c8a3af23746272d76b81302930
+  metadata.gz: e0eb7cacc7d8e3cd78f249e9fe3c11a320b1632b
+  data.tar.gz: 972f6e0a2415a2826e34c819b14272462941e81e
 SHA512:
-  metadata.gz: edc374917c8ecd75456226683d042a1bd8e48ddc3fbc2f030b95f94d1a40d8af631155249faa4247c6547d72bc7f9f13b972c903dec6233e42260a7320dd37a4
-  data.tar.gz: 0374af5803f0ed1895f3304d2b86183185349b005caaab38de7020c910ef081de49ad499cc592c33d47f8a4be9bf7b061d7dffb05bcad5695b35d635a24b65fa
+  metadata.gz: e550a9ec0fc0abfc72eb76a8948b8e26185fdd98b8898e76b10b3139e2a44e34a9013c81c8e5ddcac87b95a2b6d02d29452ad5852ba3775e37c69b4203742be8
+  data.tar.gz: 61ebedb72c0dd0380248eb8765cb0bc9f4ad6d9417bb92285eeefa9a90a81af528b7e65e7de63c534f8030db926b81ea562a49fa5984cec02d76289a8048a1fa

data/lib/graphql_includable/concern.rb

@@ -6,9 +6,8 @@ module GraphQLIncludable
 
     module ClassMethods
       def includes_from_graphql(ctx)
-        node = Resolver.find_node_by_return_type(ctx.irep_node, model_name)
+        node = Resolver.find_node_by_return_type(ctx.irep_node, name)
         generated_includes = Resolver.includes_for_node(node)
-        byebug if generated_includes == {}
         includes(generated_includes)
       rescue => e
         self

data/lib/graphql_includable/edge.rb

@@ -1,72 +1,72 @@
 module GraphQLIncludable
   class Edge < GraphQL::Relay::Edge
-    def edge
-      return @edge if @edge
-      join_chain = joins_along_edge
-      edge_class_name = join_chain.shift
-      edge_class = str_to_class(edge_class_name)
+    def edge_record
+      return @edge_record if @edge_record.present?
 
-      root_association_key = class_to_str(parent.class)
-      unless edge_class.reflections.keys.include?(root_association_key)
-        is_polymorphic = true
-        root_association_key = edge_class.reflections.select { |k, r| r.polymorphic? }.keys.first
-      end
-      root_node = { root_association_key.to_sym => [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
+      all_association_names = associations_between_node_and_parent
+      first_association_name = all_association_names.shift
+      other_association_names = all_association_names.map { |s| s.to_s.singularize }
+
+      edge_class = self.class.str_to_class(first_association_name)
+      is_polymorphic = edge_class.reflections.none? { |k, r| r.polymorphic? }
 
-      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_class = edge_class.joins(root_association_key.to_sym) unless is_polymorphic
-      @edge ||= edge_class.find_by(search_hash)
+      selector = edge_class
+      selector = selector.merge(edge_class.includes(*other_association_names)) if other_association_names.present?
+      selector = selector.merge(edge_class.joins(root_association_key.to_sym)) unless is_polymorphic
+      selector = selector.find_by(where_hash_for_edge(edge_class, all_association_names))
+
+      @edge_record = selector
     end
 
     def method_missing(method_name, *args, &block)
-      if edge.respond_to?(method_name)
-        edge.send(method_name, *args, &block)
-      else
-        super
-      end
+      return super unless edge_record.respond_to?(method_name)
+      edge_record.send(method_name, *args, &block)
     end
 
     def respond_to_missing(method_name, include_private = false)
-      edge.respond_to?(method_name) || super
+      edge_record.respond_to?(method_name) || super
     end
 
     private
+    def associations_between_node_and_parent
+      return @associations if @associations.present?
+
+      associations = []
+      association_name = node.class.name.pluralize.downcase.to_sym
+      association = parent.class.reflect_on_association(association_name)
+      while association.is_a?(ActiveRecord::Reflection::ThroughReflection)
+        associations.unshift(association.options[:through])
+        association = parent.class.reflect_on_association(association.options[:through])
+      end
 
-    def str_to_class(str)
-      str.to_s.singularize.camelize.constantize
-    rescue
+      @associations = associations
     end
 
-    def class_to_str(klass)
-      klass.name.downcase
+    def where_hash_for_edge(edge_class, association_names)
+      root_association_key = self.class.class_to_str(parent.class)
+      unless edge_class.reflections.keys.include?(root_association_key)
+        root_association_key = edge_class.reflections.select { |k, r| r.polymorphic? }.keys.first
+      end
+      root_include = { root_association_key.to_sym => [parent] }
+
+      terminal_include = { self.class.class_to_str(node.class) => node }
+      association_names.reverse.each do |rel_name|
+        terminal_include = { rel_name.to_s.pluralize => terminal_include }
+      end
+
+      root_include.merge(terminal_include)
     end
 
-    def joins_along_edge
-      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])
+    class << self
+      private
+      def self.str_to_class(str)
+        str.to_s.singularize.camelize.constantize
+      rescue
+      end
+
+      def self.class_to_str(klass)
+        klass.name.downcase
       end
-      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/resolver.rb

@@ -1,105 +1,113 @@
 module GraphQLIncludable
   class Resolver
-    # Returns the first node in the tree which returns a specific type
-    def self.find_node_by_return_type(node, desired_return_type)
-      return_type = node.return_type.unwrap
-      return node if return_type == desired_return_type
-      if node.respond_to?(:scoped_children)
-        node.scoped_children[return_type].find do |_child_name, child_node|
-          find_node_by_return_type(child_node, desired_return_type)
+    class << self
+      # Returns the first node in the tree which returns a specific type
+      def find_node_by_return_type(node, desired_return_type)
+        return_type = node.return_type.unwrap.to_s
+        return node if return_type == desired_return_type
+        if node.respond_to?(:scoped_children)
+          matching_node = nil
+          node.scoped_children.values.each do |selections|
+            matching_node = selections.values.find do |child_node|
+              find_node_by_return_type(child_node, desired_return_type)
+            end
+            break if matching_node
+          end
+          matching_node
         end
       end
-    end
-
-    # Translate a node's selections into `includes` values
-    # Combine and format children values
-    # Noop on nodes that don't return AR (so no associations to include)
-    def self.includes_for_node(node)
-      return_model = node_return_model(node)
-      return [] if return_model.blank?
 
-      children = node.scoped_children[node.return_type.unwrap]
-      nested_includes = {}
+      # Translate a node's selections into `includes` values
+      def includes_for_node(node)
+        return_model = node_return_model(node)
+        return [] if return_model.blank?
+        children = node.scoped_children[node.return_type.unwrap]
+        child_includes = children.map { |_key, child| includes_for_child(child, return_model) }
+        combine_child_includes(child_includes)
+      end
 
-      children.each_value do |child_node|
-        child_includes = includes_for_child(child_node, return_model)
+      def includes_for_child(node, parent_model)
+        attribute_name = node_predicted_association_name(node)
+        delegated_through = includes_delegated_through(parent_model, attribute_name)
+        delegated_model = model_name_to_class(delegated_through.last) if delegated_through.present?
+        association = (delegated_model || parent_model).reflect_on_association(attribute_name)
+        interceding_includes = []
+        # association = get_model_association(parent_model, attribute_name, interceding_includes)
 
-        if child_includes.is_a?(Hash)
-          nested_includes.merge!(child_includes)
-        elsif child_includes.is_a?(Array)
-          includes += child_includes
+        if association
+          child_includes = includes_for_node(node)
+          array_to_nested_hash(interceding_includes + [attribute_name, child_includes].reject(&:blank?))
+          # if node_is_relay_connection?(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
         else
-          includes << child_includes
+          # TODO: specified includes?
+          [array_to_nested_hash(interceding_includes)].reject(&:blank?)
         end
       end
 
-      includes << nested_includes if nested_includes.present?
-      includes.uniq
-    end
-
-    def self.includes_for_child(node, parent_model)
-      attribute_name = node_predicted_association_name(node)
-      delegated_through = includes_delegated_through(parent_model, attribute_name)
-      delegated_model = model_name_to_class(delegated_through.last) if delegated_through.present?
-      (delegated_model || parent_model).reflect_on_association(association_name)
-      association = get_model_association(parent_model, attribute_name, interceding_includes)
+      def combine_child_includes(child_includes)
+        includes = []
+        nested_includes = {}
+        child_includes.each do |child|
+          if child.is_a?(Hash)
+            nested_includes.merge!(child)
+          elsif child.is_a?(Array)
+            includes += child
+          else
+            includes << child
+          end
+        end
+        includes << nested_includes if nested_includes.present?
+        includes.uniq
+      end
 
-      if association
-        child_includes = includes_for_node(node)
-        array_to_nested_hash(interceding_includes + [attribute_name, child_includes].reject(&:blank?))
-        # if node_is_relay_connection?(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
-      else
-        [array_to_nested_hash(interceding_includes), specified_includes].reject(&:blank?)
+      def model_name_to_class(model_name)
+        begin
+          model_name.to_s.camelize.constantize
+        rescue NameError
+          model_name.to_s.singularize.camelize.constantize
+        end
+      rescue
       end
-    end
 
-    def self.model_name_to_class(model_name)
-      begin
-        model_name.to_s.camelize.constantize
+      # Translate a node's return type to an ActiveRecord model
+      def node_return_model(node)
+        model = Object.const_get(node.return_type.unwrap.name.gsub(/(^SquareFoot|Edge$|Connection$)/, ''))
+        model if model < ActiveRecord::Base
       rescue NameError
-        model_name.to_s.singularize.camelize.constantize
       end
-    rescue
-    end
 
-    # Translate a node's return type to an ActiveRecord model
-    def self.node_return_model(node)
-      model = Object.const_get(node.return_type.unwrap.name.gsub(/(^SquareFoot|Edge$|Connection$)/, ''))
-      model if model < ActiveRecord::Base
-    rescue NameError
-    end
+      def node_predicted_association_name(node)
+        definition = node.definitions.first
+        definition.metadata[:includes] || (definition.property || definition.name).to_sym
+      end
 
-    def self.node_predicted_association_name(node)
-      definition = node.definitions.first
-      definition.metadata[:includes] || (definition.property || definition.name).to_sym
-    end
+      # If method_name is delegated from base_model, return an array of
+      # associations through which those methods can be delegated
+      def includes_delegated_through(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
 
-    # If method_name is delegated from base_model, return an array of
-    # associations through which those methods can be delegated
-    def self.includes_delegated_through(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)
+      # Right-reduce an array into a nested hash
+      def array_to_nested_hash(arr)
+        arr.reverse.inject { |acc, item| { item => acc } } || {}
       end
-      chain
-    end
 
-    # Right-reduce an array into a nested hash
-    def self.array_to_nested_hash(arr)
-      arr.reverse.inject { |acc, item| { item => acc } } || {}
+      # def node_is_relay_connection?(node)
+      #   node.return_type.unwrap.name =~ /Connection$/
+      # end
     end
-
-    # def self.node_is_relay_connection?(node)
-    #   node.return_type.unwrap.name =~ /Connection$/
-    # end
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: graphql_includable
 version: !ruby/object:Gem::Version
-  version: 0.2.6
+  version: 0.2.7
 platform: ruby
 authors:
 - Dan Rouse
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-05-08 00:00:00.000000000 Z
+date: 2018-06-19 00:00:00.000000000 Z
 dependencies: []
 description: 
 email: