graphql_includable 0.2.11 → 0.2.12

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 8c4d33679dac4d67ec32b21e75fec07de5880b01
-  data.tar.gz: 9740f56824351816c832548ceec61a64181d53a0
+  metadata.gz: 7e15a080b64989dcfc9dfb9e9df39cf8f37c96ee
+  data.tar.gz: c0c53dcc1a61dbaab44b9c585bb5a486d0d1223b
 SHA512:
-  metadata.gz: 66b0ff3db10a0f536d400082e1645a3ebececc22e44868a89a9edb1f4dddf5f7fb32f1d3b96cd20e57ff4fc06ab8eee600706e0567129e6cafe3aee023e8f873
-  data.tar.gz: cadeae8bb2ccfdff4f5de8d03e48294278204c9138d0e92f5c1f998fb1a407bca81fcb43d7551e53a75a8b9f93a1f15825e69b340fc5974fbc8dcb11c554ddf7
+  metadata.gz: c7d535ba4e020ff2eac12c1aa81f63de740af241dfc3b1669167667afb8bf8ed6ca1edd8d761b37f847555d03a64e8c23691a91b857a93e0c985d561a0a091b1
+  data.tar.gz: 320b95f48de65e16b42033b2ef45cd921d86c57e70e98ada5600155d7204a912665db781203f090d011d4b83ed8e871825a751c43491efc427a79232f2507387

data/lib/graphql_includable/concern.rb

@@ -1,24 +1,17 @@
 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 = GraphQLIncludable::Resolver.find_node_by_return_type(ctx.irep_node, name)
-        generated_includes = GraphQLIncludable::Resolver.includes_for_node(node)
-        preload(generated_includes)
+        node = Resolver.find_node_by_return_type(ctx.irep_node, name)
+        generated_includes = Resolver.includes_for_node(node)
+        puts("INCLUDES!!!: #{generated_includes}")
+        includes(generated_includes)
       rescue => 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')}")
+        Rails.logger.error(e)
         self
       end
 
@@ -26,8 +19,6 @@ 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,107 +1,90 @@
 module GraphQLIncludable
   class Edge < GraphQL::Relay::Edge
-    # 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)
+    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)
 
-      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))
+      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
 
-      selector.find_by(
-        where_hash_for_edge(root_association_key, nested_associations)
-      )
-    end
+      if parent.class.delegate_cache&.key?(edge_class_name)
+        root_association_search_value = parent.send(parent.class.delegate_cache[edge_class_name])
+      else
+        root_association_search_value = parent
+      end
 
-    # 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
+      root_node = { root_association_key.to_sym => [root_association_search_value] }
+      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_class = edge_class.joins(root_association_key.to_sym) unless is_polymorphic
+      @edge ||= edge_class.find_by(search_hash)
     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)
+      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
+    def respond_to_missing(method_name, include_private = false)
+      edge.respond_to?(method_name) || super
     end
 
     private
 
-    # 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
+    def str_to_class(str)
+      str.to_s.singularize.camelize.constantize
+    rescue
     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)
+    def class_to_str(klass)
+      klass.name.downcase
     end
 
-    # @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
+    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
+      if parent.class.delegate_cache&.key?(edge_association_name)
+        parent_class = str_to_class(parent.class.delegate_cache[edge_association_name])
+      else
+        parent_class = parent.class
       end
-      key.to_sym
-    end
-
-    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
+      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,15 +1,10 @@
-# Includes = Symbol | Array<Symbol> | Hash<Symbol, Includes>
 module GraphQLIncludable
   class Resolver
-    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)
+    # 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|
@@ -19,185 +14,102 @@ module GraphQLIncludable
         end
         matching_node
       end
+    end
 
-      # 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
-
-      # 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)
-
-        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
-
-      # 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
-
-      # 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'])
+    # 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
         end
-        leaf_includes = array_to_nested_hash(leaf_includes)
-
-        [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
+      includes << nested_includes if nested_includes.present?
+      includes.uniq
+    end
 
-      # 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
+    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)
+        child_includes.delete(association.plural_name.singularize.to_sym) if association.options[:through]
+
+        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
-      #
-      # @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
+    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
 
-      # @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
+    # 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
 
-      # 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
+    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
-      #
-      # @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
+    # 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
-      #
-      # @param arr Array<Includes>
-      # @returns nested_hash Includes
-      def array_to_nested_hash(arr)
-        (arr || []).reject(&:blank?)
-                   .reverse
-                   .inject { |acc, item| { item => acc } } || {}
-      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.11
+  version: 0.2.12
 platform: ruby
 authors:
 - Dan Rouse
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-09-11 00:00:00.000000000 Z
+date: 2019-06-25 00:00:00.000000000 Z
 dependencies: []
 description: 
 email: