graphql_includable 0.2.8 → 0.2.10

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 3fb8b1ec2e2a339a4fe78952b2426ef79dc588a8
-  data.tar.gz: 0a528542daf9f1723fdc1c64619b68591f2e7c78
+  metadata.gz: 58421ff04b72f73e873564c8ac6cfe3d731ed59a
+  data.tar.gz: edd842cae9ab0006a27caabc27cb68792d52d718
 SHA512:
-  metadata.gz: 3e9b99fc48e697dcdda9a1fc821c6f310bb38cc555f91c4fd068ea40cfb9683b09c0e01115d9f4b005879c6942474027745cc56e984ef3c2c87e8b9cabf17bea
-  data.tar.gz: 8a896215e28522ef35f9862e7e2f89db6c228a7d20390dc52343e0f43b489d0f19a9afd00b8e6b9e9a5345ceba1bb095a82522a12ac96bf20f37a05f6a11919d
+  metadata.gz: 8f6a55a190f097a48cb8aefd9673c6d3d9b996071cd5c1d6a74103dc6592ffc6b26ce47e1f816050c4952b10f93ae108e255c0e6ec9a8234e6493451a408aa27
+  data.tar.gz: 897f124f919a46f4885e50f9ff2fd54f2c64ca6d7eaced6cd9bad2c6c8223e5ab785fab95a462168e5e699436e7de715201eacd093cf5d0b2d1ff2db68c11fc5

data/lib/graphql_includable/concern.rb

@@ -1,16 +1,24 @@
 require 'active_support/concern'
+require 'logger'
 
 module GraphQLIncludable
+  # ActiveSupport::Concern to include onto GraphQL-mapped models
   module Concern
     extend ActiveSupport::Concern
 
     module ClassMethods
+      # Main entry point of the concern, to be called from top-level fields
+      # Accepts a graphql-ruby query context, preloads, and returns itself
+      # @param ctx GraphQL::Query::Context
       def includes_from_graphql(ctx)
-        node = Resolver.find_node_by_return_type(ctx.irep_node, name)
-        generated_includes = Resolver.includes_for_node(node)
+        node = GraphQLIncludable::Resolver.find_node_by_return_type(ctx.irep_node, name)
+        generated_includes = GraphQLIncludable::Resolver.includes_for_node(node)
         includes(generated_includes)
       rescue => e
-        Rails.logger.error(e)
+        # As this feature is just for a performance gain, it should never
+        # fail destructively, so catch and log all exceptions, but continue
+        raise e if Rails && Rails.env.development?
+        Rails.logger.debug("#{e.message}\n#{e.backtrace.join('\n')}")
         self
       end
 
@@ -18,6 +26,8 @@ module GraphQLIncludable
         @delegate_cache ||= {}
       end
 
+      # Hook and cache all calls to ActiveRecord's `delegate` method,
+      # so that preloading can take place through delegated models
       def delegate(*methods, args)
         methods.each do |method|
           delegate_cache[method] = args[:to]

data/lib/graphql_includable/edge.rb

@@ -1,78 +1,115 @@
 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)
-
-      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
+    # edge_record represents the data in between `node` and `parent`,
+    # basically the `through` record in a has-many-through association
+    # @returns record ActiveRecord::Base
+    def edge_record
+      @edge_record ||= edge_record_from_memory || edge_record_from_database
+    end
+
+    # attempt to query the edge record freshly from the database
+    # @returns record ActiveRecord::Base
+    def edge_record_from_database
+      first_association, *nested_associations = associations_between_node_and_parent
+      edge_class = self.class.str_to_class(first_association)
+      root_association_key = root_association_key(edge_class)
+
+      selector = edge_class
+
+      if nested_associations.present?
+        nested_association_names = nested_associations.map { |s| s.to_s.singularize }
+        selector = selector.merge(edge_class.includes(*nested_association_names))
       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 }
+
+      if class_is_polymorphic?(edge_class)
+        selector = selector.merge(edge_class.joins(root_association_key))
       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_class = edge_class.joins(root_association_key.to_sym) unless is_polymorphic
-      @edge ||= edge_class.find_by(search_hash)
+      selector.find_by(
+        where_hash_for_edge(root_association_key, nested_associations)
+      )
     end
 
-    def method_missing(method_name, *args, &block)
-      if edge.respond_to?(method_name)
-        edge.send(method_name, *args, &block)
-      else
-        super
+    # attempt to pull the preloaded edge record out of the associated object in memory
+    # @returns record ActiveRecord::Base
+    def edge_record_from_memory
+      associations = associations_between_node_and_parent
+      records = associations.reverse.reduce(parent) { |acc, cur| acc.send(cur) }
+      return unless records.loaded?
+      records.first do |rec|
+        child_association_name = node.class.name.downcase.to_sym
+        rec.send(root_association_key) == parent && rec.send(child_association_name) == node
       end
     end
 
-    def respond_to_missing(method_name, include_private = false)
-      edge.respond_to?(method_name) || super
+    def class_is_polymorphic?(klass)
+      klass.reflections.any? { |_k, r| r.polymorphic? }
+    end
+
+    # Delegate method calls on this Edge instance to the ActiveRecord instance
+    def method_missing(method_name, *args, &block)
+      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_record.respond_to?(method_name) || super
     end
 
     private
 
-    def str_to_class(str)
-      str.to_s.singularize.camelize.constantize
-    rescue
+    # List all HasManyThrough associations between node and parent models
+    # @returns associations Array<Symbol>
+    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
+    end
+
+    # List the key:value criteria for finding the edge record in the database
+    # @param root_key Symbol
+    # @param nested_associations Array<Symbol>
+    # @returns where_hash Hash<?>
+    def where_hash_for_edge(root_key, nested_associations)
+      root_include = { root_key => [parent] }
+      terminal_include = { self.class.class_to_str(node.class) => node }
+      inner_includes = nested_associations.reverse.reduce(terminal_include) do |acc, rel_name|
+        { rel_name.to_s.pluralize => acc }
+      end
+      root_include.merge(inner_includes)
     end
 
-    def class_to_str(klass)
-      klass.name.downcase
+    # @param edge_class ActiveRecord::Base
+    # @returns key Symbol
+    def root_association_key(edge_class)
+      key = self.class.class_to_str(parent.class)
+      unless edge_class.reflections.keys.include?(key)
+        key = edge_class.reflections.select { |_k, r| r.polymorphic? }.keys.first
+      end
+      key.to_sym
     end
 
-    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])
+    class << self
+      # @param str String
+      # @returns klass Class
+      def str_to_class(str)
+        str.to_s.singularize.camelize.constantize
+      rescue # rubocop:disable Lint/HandleExceptions
+      end
+
+      # @param klass Class
+      # @returns str String
+      def 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,10 +1,15 @@
+# Includes = Symbol | Array<Symbol> | Hash<Symbol, Includes>
 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.to_s
-      return node if return_type == desired_return_type
-      if node.respond_to?(:scoped_children)
+    class << self
+      # Returns the first node in the tree which returns a specific type
+      # @param node GraphQL::InternalRepresentation::Node
+      # @param desired_return_type String
+      # @returns matching_node GraphQL::InternalRepresentation::Node
+      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
+        return unless node.respond_to?(:scoped_children)
         matching_node = nil
         node.scoped_children.values.each do |selections|
           matching_node = selections.values.find do |child_node|
@@ -14,100 +19,185 @@ module GraphQLIncludable
         end
         matching_node
       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?
-
-      includes = []
-      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
+      # Collect preloadable relationships for the resolution of `node`
+      #
+      # @param node GraphQL::InternalRepresentation::Node
+      # @returns includes Includes
+      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_node_child(child, return_model) }
+        combine_child_includes(child_includes)
+      end
+
+      # Collect preloadable relationships for all selections on `node`,
+      # as accessed from `parent_model`.
+      #
+      # @param node GraphQL::InternalRepresentation::Node
+      # @param parent_model ActiveRecord::Base
+      # @returns child_includes Includes
+      def includes_for_node_child(node, parent_model)
+        included_attributes = node_includes_source_from_metadata(node)
+        return included_attributes if included_attributes.is_a?(Hash)
+        included_attributes = [included_attributes] unless included_attributes.is_a?(Array)
+        includes = included_attributes.map do |attribute_name|
+          includes_for_node_child_attribute(node, parent_model, attribute_name)
         end
+        includes.size == 1 ? includes.first : includes
       end
 
-      includes << nested_includes if nested_includes.present?
-      includes.uniq
-    end
+      # Collect preloadable relationships for a single selection on `node`,
+      # as accessed from `parent_model`
+      #
+      # @param node GraphQL::InternalRepresentation::Node
+      # @param parent_model ActiveRecord::Base
+      # @param attribute_name Symbol
+      # @returns includes Includes
+      def includes_for_node_child_attribute(node, parent_model, attribute_name)
+        includes_array = includes_delegated_through(parent_model, attribute_name)
+        target_model = model_name_to_class(includes_array.last) || parent_model
+        association = target_model.reflect_on_association(attribute_name)
 
-    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?)
+        if association && node_is_relay_connection?(node)
+          includes_array << includes_for_node_relay_child_attribute(
+            node, attribute_name, association
+          )
+        elsif association
+          includes_array += [attribute_name, includes_for_node(node)]
+        end
+        array_to_nested_hash(includes_array)
       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
+      # Collect preloadable relationships for a single selection on `node`,
+      # as accessed from `parent_model`, through the Relay specification's
+      # named `edges` and `nodes` selections.
+      #
+      # @param node GraphQL::InternalRepresentation::Node
+      # @param attribute_name Symbol
+      # @param association ActiveRecord::HasManyThroughAssociation
+      def includes_for_node_relay_child_attribute(node, attribute_name, association)
+        children = node.scoped_children[node.return_type.unwrap]
+
+        edge_data = includes_for_node_relay_child_edge_attribute(
+          children['edges'], attribute_name, association
+        )
+        leaf_data = [attribute_name, includes_for_node(node)] if children['nodes']
+
+        [array_to_nested_hash(edge_data), array_to_nested_hash(leaf_data)].reject(&:blank?)
       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
+      # Collect preloadable relationships for a single selection on `node`,
+      # a Relay Edge node whose parent is a Connection being accessed from `parent_model`
+      #
+      # @param node GraphQL::InternalRepresentation::Node
+      # @param attribute_name Symbol
+      # @param association ActiveRecord::HasManyThroughAssociation
+      def includes_for_node_relay_child_edge_attribute(node, attribute_name, association)
+        return unless node
+        leaf_includes = [attribute_name.to_s.singularize.to_sym]
+        edge_children = node.scoped_children[node.return_type.unwrap]
+        if edge_children['node']
+          leaf_includes << includes_for_node(edge_children['node'])
+        end
+        leaf_includes = array_to_nested_hash(leaf_includes)
 
-    def self.node_predicted_association_name(node)
-      definition = node.definitions.first
-      definition.metadata[:includes] || (definition.property || definition.name).to_sym
-    end
+        [association.options[:through], [*includes_for_node(node), leaf_includes]]
+      end
+
+      # Format child includes into a data structure that can be preloaded
+      # Singular terminal nodes become symbols,
+      # multiple terminal nodes become arrays of symbols,
+      # and branching nodes become hashes.
+      # The result can be passed directly into ActiveModel::Base.includes
+      #
+      # @param child_includes Includes
+      # @returns child_includes 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.reject(&:blank?)
+      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)
+      # Retrieve the Ruby class for a model by name
+      # Attempts to singularize the name if not found
+      #
+      # @param model_name Symbol | String
+      # @returns klass Class
+      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 # rubocop:disable Lint/HandleExceptions
       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
+      # Translate a node's return type to an ActiveRecord model
+      #
+      # @param node GraphQL::InternalRepresentation::Node
+      # @returns model ActiveRecord::Base | nil
+      REGEX_CLEAN_GQL_TYPE_NAME = /(^SquareFoot|Edge$|Connection$)/
+      def node_return_model(node)
+        model = Object.const_get(node.return_type.unwrap.name.gsub(REGEX_CLEAN_GQL_TYPE_NAME, ''))
+        model if model < ActiveRecord::Base
+      rescue NameError # rubocop:disable Lint/HandleExceptions
+      end
+
+      # @param node GraphQL::InternalRepresentation::Node
+      # @returns is_relay_connection Boolean
+      REGEX_RELAY_CONNECTION = /Connection$/
+      def node_is_relay_connection?(node)
+        node.return_type.unwrap.name =~ REGEX_RELAY_CONNECTION
+      end
 
-    # def self.node_is_relay_connection?(node)
-    #   node.return_type.unwrap.name =~ /Connection$/
-    # end
+      # Predict the association name to include from a field's metadata
+      #
+      # @param node GraphQL::InternalRepresentation::Node
+      # @returns possible_includes Includes
+      def node_includes_source_from_metadata(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
+      #
+      # @param base_model ActiveRecord::Base
+      # @param method_name String | Symbol
+      # @returns chain Array<Symbol>
+      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
+
+      # Right-reduce an array into a nested hash
+      #
+      # @param arr Array<Includes>
+      # @returns nested_hash Includes
+      def array_to_nested_hash(arr)
+        (arr || []).reject(&:blank?)
+                   .reverse
+                   .inject { |acc, item| { item => acc } } || {}
+      end
+    end
   end
 end

metadata

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