graphql_includable 0.2.7 → 0.2.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: e0eb7cacc7d8e3cd78f249e9fe3c11a320b1632b
-  data.tar.gz: 972f6e0a2415a2826e34c819b14272462941e81e
+  metadata.gz: 3fb8b1ec2e2a339a4fe78952b2426ef79dc588a8
+  data.tar.gz: 0a528542daf9f1723fdc1c64619b68591f2e7c78
 SHA512:
-  metadata.gz: e550a9ec0fc0abfc72eb76a8948b8e26185fdd98b8898e76b10b3139e2a44e34a9013c81c8e5ddcac87b95a2b6d02d29452ad5852ba3775e37c69b4203742be8
-  data.tar.gz: 61ebedb72c0dd0380248eb8765cb0bc9f4ad6d9417bb92285eeefa9a90a81af528b7e65e7de63c534f8030db926b81ea562a49fa5984cec02d76289a8048a1fa
+  metadata.gz: 3e9b99fc48e697dcdda9a1fc821c6f310bb38cc555f91c4fd068ea40cfb9683b09c0e01115d9f4b005879c6942474027745cc56e984ef3c2c87e8b9cabf17bea
+  data.tar.gz: 8a896215e28522ef35f9862e7e2f89db6c228a7d20390dc52343e0f43b489d0f19a9afd00b8e6b9e9a5345ceba1bb095a82522a12ac96bf20f37a05f6a11919d

data/lib/graphql_includable/concern.rb

@@ -10,6 +10,7 @@ module GraphQLIncludable
         generated_includes = Resolver.includes_for_node(node)
         includes(generated_includes)
       rescue => e
+        Rails.logger.error(e)
         self
       end
 

data/lib/graphql_includable/edge.rb

@@ -1,72 +1,78 @@
 module GraphQLIncludable
   class Edge < GraphQL::Relay::Edge
-    def edge_record
-      return @edge_record if @edge_record.present?
+    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)
 
-      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? }
-
-      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))
+      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
 
-      @edge_record = selector
+      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)
     end
 
     def method_missing(method_name, *args, &block)
-      return super unless edge_record.respond_to?(method_name)
-      edge_record.send(method_name, *args, &block)
+      if edge.respond_to?(method_name)
+        edge.send(method_name, *args, &block)
+      else
+        super
+      end
     end
 
     def respond_to_missing(method_name, include_private = false)
-      edge_record.respond_to?(method_name) || super
+      edge.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
 
-      @associations = associations
+    def str_to_class(str)
+      str.to_s.singularize.camelize.constantize
+    rescue
     end
 
-    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)
+    def class_to_str(klass)
+      klass.name.downcase
     end
 
-    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
+    def joins_along_edge
+      # node.edges
+      # edge.node
+      # edge.parent
+      # parent.edges
+      # node.parents
+      # parent.nodes
+      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
+      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,113 +1,113 @@
 module GraphQLIncludable
   class Resolver
-    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
+    # 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.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
-          matching_node
+          break if matching_node
         end
+        matching_node
       end
+    end
 
-      # 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
+    # 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?
+
+      includes = []
+      children = node.scoped_children[node.return_type.unwrap]
+      nested_includes = {}
 
-      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)
+      children.each_value do |child_node|
+        child_includes = includes_for_child(child_node, return_model)
 
-        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
+        if child_includes.is_a?(Hash)
+          nested_includes.merge!(child_includes)
+        elsif child_includes.is_a?(Array)
+          includes += child_includes
         else
-          # TODO: specified includes?
-          [array_to_nested_hash(interceding_includes)].reject(&:blank?)
+          includes << child_includes
         end
       end
 
-      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
+      includes << nested_includes if nested_includes.present?
+      includes.uniq
+    end
 
-      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
+    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?
+      association = (delegated_model || parent_model).reflect_on_association(attribute_name)
+      interceding_includes = []
+      # association = get_model_association(parent_model, attribute_name, interceding_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
+        # TODO: specified includes?
+        [array_to_nested_hash(interceding_includes)].reject(&:blank?)
       end
+    end
 
-      # 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
+    def self.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
 
-      def node_predicted_association_name(node)
-        definition = node.definitions.first
-        definition.metadata[:includes] || (definition.property || definition.name).to_sym
-      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
 
-      # 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
+    def self.node_predicted_association_name(node)
+      definition = node.definitions.first
+      definition.metadata[:includes] || (definition.property || definition.name).to_sym
+    end
 
-      # Right-reduce an array into a nested hash
-      def array_to_nested_hash(arr)
-        arr.reverse.inject { |acc, item| { item => acc } } || {}
+    # 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)
       end
+      chain
+    end
 
-      # def node_is_relay_connection?(node)
-      #   node.return_type.unwrap.name =~ /Connection$/
-      # end
+    # Right-reduce an array into a nested hash
+    def self.array_to_nested_hash(arr)
+      arr.reverse.inject { |acc, item| { item => acc } } || {}
     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.7
+  version: 0.2.8
 platform: ruby
 authors:
 - Dan Rouse