graphql_includable 0.2.3 → 0.2.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 67916fbd68ce3698cbecbc818655408ba89f8f1a
-  data.tar.gz: 930edfc340b740528fd689b2bfd196f2f81aeef8
+  metadata.gz: 6545a0cd3202a2d518e38696954b7797fd185684
+  data.tar.gz: 484b44d89aacbc52585f73657646fd12cd770ef6
 SHA512:
-  metadata.gz: 48fe0a1f6e0bb028e7f643df33ecfcecec7701cfc382f33cb0928305a00fa6b6007e3e71ed5890be67b25d50c41079dfbfdbaece299c18e1c47f85ed116ad8a0
-  data.tar.gz: cd524919a412f7e98dff775b2b676d16c6fd30868c8f63f982c44e6a10110cd3cbb7dc2ecf93d0d91034561f3282b47a804e67afd3845cbc538e3c66891839f9
+  metadata.gz: 8c3562e409a36d572f2899d21317a382eacda8d0c8f5413f0faa37423a5161c83278b7182dd99146c1bc3be095bfddd5419fa3ae279056b50964f5a66407b900
+  data.tar.gz: afe70bfba8d8f6459ff67301e44de68a5bcb66309ef9c293e803b8e77a6a05f05c5a812a2f55d99a56d2968d538f50a3d727c2011f1b6a47ca3b8e0aeba76922

data/lib/graphql_includable/resolver.rb

@@ -0,0 +1,105 @@
+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)
+        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 = {}
+
+      children.each_value do |child_node|
+        child_includes = includes_for_child(child_node, return_model)
+
+        if child_includes.is_a?(Hash)
+          nested_includes.merge!(child_includes)
+        elsif child_includes.is_a?(Array)
+          includes += child_includes
+        else
+          includes << child_includes
+        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)
+
+      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?)
+      end
+    end
+
+    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
+
+    # 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 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 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
+
+    # 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.3
+  version: 0.2.4
 platform: ruby
 authors:
 - Dan Rouse
@@ -22,6 +22,7 @@ files:
 - lib/graphql_includable.rb
 - lib/graphql_includable/concern.rb
 - lib/graphql_includable/edge.rb
+- lib/graphql_includable/resolver.rb
 homepage: https://github.com/thesquarefoot/graphql_includable
 licenses:
 - MIT