graphql_includable 0.5.0 → 1.0.0.beta.0

data/lib/graphql_includable/resolver.rb

@@ -1,92 +1,51 @@
+GraphQL::Field.accepts_definitions(
+  ##
+  # Define Active Record includes for a field
+  includes: GraphQL::Define.assign_metadata_key(:includes)
+)
+
 module GraphQLIncludable
-  class IncludesManager
-    def initialize(parent_attribute)
-      @parent_attribute = parent_attribute
-      @included_children = {}
+  class Resolver
+    def initialize(ctx)
+      @root_ctx = ctx
     end
 
-    def add_child_include(association)
-      return @included_children[association.name] if @included_children.key?(association.name)
-
-      manager = IncludesManager.new(association.name)
-      @included_children[association.name] = manager
-      manager
-    end
+    def includes_for_node(node, includes)
+      return includes_for_top_level_connection(node, includes) if node.definition.connection?
 
-    def empty?
-      @included_children.empty?
+      children = node.scoped_children[node.return_type.unwrap]
+      children.each_value do |child_node|
+        definition_override = node_definition_override(node, child_node)
+        includes_for_child(child_node, includes, definition_override)
+      end
     end
 
-    def includes
-      child_includes = {}
-      child_includes_arr = []
-      @included_children.each do |key, value|
-        if value.empty?
-          child_includes_arr << key
-        else
-          includes = value.includes
-          if includes.is_a?(Array)
-            child_includes_arr += includes
-          else
-            child_includes.merge!(includes)
-          end
-        end
-      end
+    private
 
-      if child_includes_arr.present?
-        child_includes_arr << child_includes if child_includes.present?
-        child_includes = child_includes_arr
-      end
+    def includes_for_child(node, includes, definition_override)
+      return includes_for_connection(node, includes, definition_override) if node.definition.connection?
 
-      return child_includes if @parent_attribute.nil?
-      { @parent_attribute => child_includes }
-    end
-  end
+      builder = build_includes(node, definition_override)
+      return unless builder.present?
+      includes.merge_includes(builder.includes) unless builder.includes.empty?
 
-  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
-      return nil unless 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
+      return unless builder.includes?
 
-    # 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, includes_manager)
-      return_model = node_return_model(node)
-      return [] if return_model.blank?
+      # Determine which [nested] child Includes manager to send to the children
+      child_includes = includes.dig(builder.included_path)
 
       children = node.scoped_children[node.return_type.unwrap]
-
       children.each_value do |child_node|
-        includes_for_child(child_node, return_model, includes_manager)
+        definition_override = node_definition_override(node, child_node)
+        includes_for_child(child_node, child_includes, definition_override)
       end
     end
 
     # rubocop:disable Metrics/AbcSize
     # rubocop:disable Metrics/MethodLength
-    def self.includes_from_connection(node, _parent_model, associations_from_parent_model, includes_manager)
-      # TODO: Possibly basic support for connections with only nodes
-      return unless node.return_type.fields['edges'].edge_class <= GraphQLIncludable::Relay::EdgeWithNode
-
-      edges_association = associations_from_parent_model[:edges]
-      nodes_association = associations_from_parent_model[:nodes]
-
-      edge_node_attribute = node.definition.metadata[:edge_to_node_property]
-      edge_model = edges_association.klass
-      edge_to_node_association = edge_model.reflect_on_association(edge_node_attribute)
-      node_model = edge_to_node_association.klass
+    def includes_for_connection(node, includes, definition_override)
+      builder = build_connection_includes(node, definition_override)
+      return unless builder&.includes?
 
       connection_children = node.scoped_children[node.return_type.unwrap]
       connection_children.each_value do |connection_node|
@@ -105,109 +64,138 @@ module GraphQLIncludable
         # }
 
         if connection_node.name == 'edges'
-          edges_includes_manager = includes_manager.add_child_include(edges_association)
+          edges_includes_builder = builder.edges_builder.builder
+          includes.merge_includes(edges_includes_builder.includes)
+          edges_includes = edges_includes_builder.path_leaf_includes
 
           edge_children = connection_node.scoped_children[connection_node.return_type.unwrap]
           edge_children.each_value do |edge_child_node|
             if edge_child_node.name == 'node'
-              node_includes_manager = edges_includes_manager.add_child_include(edge_to_node_association)
+              node_includes_builder = builder.edges_builder.node_builder
+              edges_includes.merge_includes(node_includes_builder.includes)
+              edge_node_includes = node_includes_builder.path_leaf_includes
 
               node_children = edge_child_node.scoped_children[edge_child_node.return_type.unwrap]
               node_children.each_value do |node_child_node|
-                includes_for_child(node_child_node, node_model, node_includes_manager)
+                definition_override = node_definition_override(edge_child_node, node_child_node)
+                includes_for_child(node_child_node, edge_node_includes, definition_override)
               end
             else
-              includes_for_child(edge_child_node, edge_model, edges_includes_manager)
+              definition_override = node_definition_override(connection_node, edge_child_node)
+              includes_for_child(edge_child_node, edges_includes, definition_override)
             end
           end
         elsif connection_node.name == 'nodes'
-          nodes_includes_manager = includes_manager.add_child_include(nodes_association)
+          nodes_includes_builder = builder.nodes_builder
+          includes.merge_includes(nodes_includes_builder.includes)
+          nodes_includes = nodes_includes_builder.path_leaf_includes
+
           node_children = connection_node.scoped_children[connection_node.return_type.unwrap]
           node_children.each_value do |node_child_node|
-            includes_for_child(node_child_node, node_model, nodes_includes_manager)
+            definition_override = node_definition_override(connection_node, node_child_node)
+            includes_for_child(node_child_node, nodes_includes, definition_override)
           end
         elsif connection_node.name == 'totalCount'
-          # Handled using `.size` - if includes() grabbed edges/nodes it will .length else, a COUNT query saving memory.
+          # Handled using `.size`
         end
       end
     end
-    # rubocop:enable Metrics/MethodLength
-    # rubocop:enable Metrics/AbcSize
-
-    def self.includes_for_child(node, parent_model, includes_manager)
-      associations = possible_associations(node, parent_model)
-      return unless associations.present?
 
-      if node_is_relay_connection?(node)
-        includes_from_connection(node, parent_model, associations, includes_manager)
+    # Special case:
+    # When includes_for_node is called within a connection resolver, there is no need to use that field's nodes/edges
+    # includes, only edge_to_node includes
+    def includes_for_top_level_connection(node, includes)
+      connection_children = node.scoped_children[node.return_type.unwrap]
+      top_level_being_resolved = @root_ctx.namespace(:gql_includable)[:resolving]
+
+      if top_level_being_resolved == :edges
+        builder = build_connection_includes(node, nil)
+        return unless builder&.edges_builder&.node_builder&.includes?
+
+        edges_node = connection_children['edges']
+        edges_includes = includes
+
+        edge_children = edges_node.scoped_children[edges_node.return_type.unwrap]
+        edge_children.each_value do |edge_child_node|
+          if edge_child_node.name == 'node'
+            node_includes_builder = builder.edges_builder.node_builder
+            edges_includes.merge_includes(node_includes_builder.includes)
+            edge_node_includes = node_includes_builder.path_leaf_includes
+
+            node_children = edge_child_node.scoped_children[edge_child_node.return_type.unwrap]
+            node_children.each_value do |node_child_node|
+              definition_override = node_definition_override(edge_child_node, node_child_node)
+              includes_for_child(node_child_node, edge_node_includes, definition_override)
+            end
+          else
+            definition_override = node_definition_override(edges_node, edge_child_node)
+            includes_for_child(edge_child_node, edges_includes, definition_override)
+          end
+        end
       else
-        association = associations[:default] # should only be one
-        child_includes_manager = includes_manager.add_child_include(association)
-        includes_for_node(node, child_includes_manager)
+        nodes_node = connection_children['nodes']
+        return unless nodes_node.present?
+        nodes_includes = includes
+
+        node_children = nodes_node.scoped_children[nodes_node.return_type.unwrap]
+        node_children.each_value do |node_child_node|
+          definition_override = node_definition_override(nodes_node, node_child_node)
+          includes_for_child(node_child_node, nodes_includes, definition_override)
+        end
       end
     end
+    # rubocop:enable Metrics/MethodLength
+    # rubocop:enable Metrics/AbcSize
 
-    # 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
+    def build_includes(node, definition_override)
+      definition = definition_override || node.definition
+      includes_meta = definition.metadata[:includes]
+      return nil if includes_meta.blank?
 
-    # 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
-    # rubocop:enable Lint/HandleExceptions
+      builder = GraphQLIncludable::IncludesBuilder.new
 
-    def self.node_is_relay_connection?(node)
-      node.return_type.unwrap.name =~ /Connection$/
-    end
+      if includes_meta.is_a?(Proc)
+        if includes_meta.arity == 2
+          args_for_field = @root_ctx.query.arguments_for(node, node.definition)
+          builder.instance_exec(args_for_field, @root_ctx, &includes_meta)
+        else
+          builder.instance_exec(&includes_meta)
+        end
+      else
+        builder.path(includes_meta)
+      end
 
-    def self.possible_associations(node, parent_model)
-      attribute_names = node_possible_association_names(node)
-      attribute_names.transform_values { |attribute_name| figure_out_association(attribute_name, parent_model) }.compact
+      builder
     end
 
-    def self.node_possible_association_names(node)
-      definition = node.definitions.first
-      user_includes = definition.metadata[:includes]
+    def build_connection_includes(node, definition_override)
+      definition = definition_override || node.definition
+      includes_meta = definition.metadata[:includes]
+      return nil if includes_meta.blank?
 
-      association_names = {}
-      if node_is_relay_connection?(node)
-        association_names[:edges] = user_includes[:edges] if user_includes.key?(:edges)
-        association_names[:nodes] = user_includes[:nodes] if user_includes.key?(:nodes)
-        return association_names if association_names.present? # This will have resolve procs for nodes and edges
+      builder = GraphQLIncludable::ConnectionIncludesBuilder.new
+      if includes_meta.arity == 2
+        args_for_field = @root_ctx.query.arguments_for(node, node.definition)
+        builder.instance_exec(args_for_field, @root_ctx, &includes_meta)
+      else
+        builder.instance_exec(&includes_meta)
       end
-
-      association_names[:default] = user_includes || (definition.property || definition.name).to_sym
-      association_names
+      builder
     end
 
-    def self.figure_out_association(attribute_name, parent_model)
-      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)
-      association
-    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
+    def node_definition_override(parent_node, child_node)
+      node_return_type = parent_node.return_type.unwrap
+      child_node_parent_type = child_node.parent.return_type.unwrap
+
+      return nil unless child_node_parent_type != node_return_type
+      child_node_definition_override = nil
+      # Handle GraphQL interface with overridden fields
+      # GraphQL makes child_node.return_type the interface instance
+      # and therefore takes the metadata from the interface rather than the
+      # implementing object's overridden field instance
+      is_interface = node_return_type.interfaces.include?(child_node_parent_type)
+      child_node_definition_override = node_return_type.fields[child_node.name] if is_interface
+      child_node_definition_override
     end
   end
 end

data/lib/graphql_includable.rb

@@ -1,33 +1,41 @@
 require 'graphql'
-require 'graphql_includable/resolver'
-require 'graphql_includable/concern'
-require 'graphql_includable/edge'
-require 'graphql_includable/relay/edge_with_node'
-require 'graphql_includable/relay/edge_with_node_connection'
-require 'graphql_includable/relay/edge_with_node_connection_type'
-require 'graphql_includable/relay/instrumentation/connection'
-require 'graphql_includable/new/gql_includable'
+require_relative 'graphql_includable/includes_builder'
+require_relative 'graphql_includable/includes'
+require_relative 'graphql_includable/resolver'
+require_relative 'graphql_includable/relay/edge_with_node_connection_type'
+require_relative 'graphql_includable/relay/instrumentation'
 
-GraphQL::Field.accepts_definitions(
-  includes: GraphQL::Define.assign_metadata_key(:includes),
-  edge_to_node_property: GraphQL::Define.assign_metadata_key(:edge_to_node_property),
-  resolve_edges: GraphQL::Define.assign_metadata_key(:resolve_edges),
-  resolve_nodes: GraphQL::Define.assign_metadata_key(:resolve_nodes),
-  # Internal use
-  _includable_connection_marker: GraphQL::Define.assign_metadata_key(:_includable_connection_marker)
-)
+module GraphQLIncludable
+  def self.includes(ctx, starting_at: nil)
+    ActiveSupport::Notifications.instrument('graphql_includable.includes') do |instrument|
+      instrument[:operation_name] = ctx.query&.operation_name
+      instrument[:field_name] = ctx.irep_node.name
+      instrument[:starting_at] = starting_at
 
-module GraphQL
-  class BaseType
-    def define_includable_connection(**kwargs, &block)
-      warn '[DEPRECATION] `define_includable_connection` is deprecated. Use `define_connection_with_fetched_edge`.'
-      define_connection(
-        edge_class: GraphQLIncludable::Edge,
-        **kwargs,
-        &block
-      )
+      includes = Includes.new(nil)
+      resolver = Resolver.new(ctx)
+
+      node = ctx.irep_node
+      node = node_for_path(node, starting_at) if starting_at.present?
+
+      generated_includes = if node.present?
+                             resolver.includes_for_node(node, includes)
+                             includes.active_record_includes
+                           end
+
+      instrument[:includes] = generated_includes
+      generated_includes
     end
+  end
 
+  def self.node_for_path(node, path_into_query)
+    children = node.scoped_children[node.return_type.unwrap]&.with_indifferent_access || {}
+    children.dig(path_into_query)
+  end
+end
+
+module GraphQL
+  class BaseType
     def define_connection_with_fetched_edge(**kwargs, &block)
       GraphQLIncludable::Relay::EdgeWithNodeConnectionType.create_type(
         self,

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: graphql_includable
 version: !ruby/object:Gem::Version
-  version: 0.5.0
+  version: 1.0.0.beta.0
 platform: ruby
 authors:
 - Dan Rouse
@@ -10,7 +10,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-09-24 00:00:00.000000000 Z
+date: 2019-10-04 00:00:00.000000000 Z
 dependencies: []
 description: 
 email:
@@ -22,20 +22,12 @@ extensions: []
 extra_rdoc_files: []
 files:
 - lib/graphql_includable.rb
-- lib/graphql_includable/concern.rb
-- lib/graphql_includable/edge.rb
-- lib/graphql_includable/new/gql_includable.rb
-- lib/graphql_includable/new/includes.rb
-- lib/graphql_includable/new/includes_builder.rb
-- lib/graphql_includable/new/relay/edge_with_node.rb
-- lib/graphql_includable/new/relay/edge_with_node_connection.rb
-- lib/graphql_includable/new/relay/edge_with_node_connection_type.rb
-- lib/graphql_includable/new/relay/instrumentation.rb
-- lib/graphql_includable/new/resolver.rb
+- lib/graphql_includable/includes.rb
+- lib/graphql_includable/includes_builder.rb
 - lib/graphql_includable/relay/edge_with_node.rb
 - lib/graphql_includable/relay/edge_with_node_connection.rb
 - lib/graphql_includable/relay/edge_with_node_connection_type.rb
-- lib/graphql_includable/relay/instrumentation/connection.rb
+- lib/graphql_includable/relay/instrumentation.rb
 - lib/graphql_includable/resolver.rb
 homepage: https://github.com/thesquarefoot/graphql_includable
 licenses:
@@ -52,9 +44,9 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">="
+  - - ">"
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 1.3.1
 requirements: []
 rubyforge_project: 
 rubygems_version: 2.6.14.1

data/lib/graphql_includable/concern.rb

@@ -1,39 +0,0 @@
-require 'active_support/concern'
-
-module GraphQLIncludable
-  module Concern
-    extend ActiveSupport::Concern
-
-    module ClassMethods
-      def includes_from_graphql(ctx)
-        warn '[DEPRECATION] `includes_from_graphql` is deprecated. See migration guide in README.'
-        ActiveSupport::Notifications.instrument('graphql_includable.includes_from_graphql') do |instrument|
-          instrument[:operation_name] = ctx.query&.operation_name
-          instrument[:field_name] = ctx.irep_node.name
-
-          node = Resolver.find_node_by_return_type(ctx.irep_node, name)
-          manager = IncludesManager.new(nil)
-          Resolver.includes_for_node(node, manager)
-
-          generated_includes = manager.includes
-          instrument[:includes] = generated_includes
-          includes(generated_includes)
-        end
-      rescue => e
-        Rails.logger.error(e)
-        self
-      end
-
-      def delegate_cache
-        @delegate_cache ||= {}
-      end
-
-      def delegate(*methods, args)
-        methods.each do |method|
-          delegate_cache[method] = args[:to]
-        end
-        super(*methods, args) if defined?(super)
-      end
-    end
-  end
-end

data/lib/graphql_includable/edge.rb

@@ -1,108 +0,0 @@
-# rubocop:disable Style/ConditionalAssignment
-# rubocop:disable Lint/HandleExceptions
-# rubocop:disable Metrics/AbcSize
-# rubocop:disable Style/IfInsideElse
-# rubocop:disable Metrics/MethodLength
-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)
-
-      parent = if self.parent.instance_of?(GraphQLIncludable::New::Relay::LazyEvaluatedNode)
-                 parent_class = self.parent._value.class
-                 self.parent._value
-               else
-                 parent_class = self.parent.class
-                 self.parent
-               end
-
-      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
-
-      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
-
-      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
-
-    def method_missing(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.respond_to?(method_name) || super
-    end
-
-    private
-
-    def str_to_class(str)
-      str.to_s.singularize.camelize.constantize
-    rescue
-    end
-
-    def class_to_str(klass)
-      klass.name.downcase
-    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
-      if parent.instance_of?(GraphQLIncludable::New::Relay::LazyEvaluatedNode)
-        parent_class = parent._value.class
-      else
-        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
-      end
-      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/new/gql_includable.rb

@@ -1,49 +0,0 @@
-require 'graphql'
-require_relative 'includes_builder'
-require_relative 'includes'
-require_relative 'resolver'
-require_relative 'relay/edge_with_node_connection_type'
-require_relative 'relay/instrumentation'
-
-module GraphQLIncludable
-  module New
-    def self.includes(ctx, starting_at: nil)
-      ActiveSupport::Notifications.instrument('graphql_includable.includes') do |instrument|
-        instrument[:operation_name] = ctx.query&.operation_name
-        instrument[:field_name] = ctx.irep_node.name
-        instrument[:starting_at] = starting_at
-
-        includes = Includes.new(nil)
-        resolver = Resolver.new(ctx)
-
-        node = ctx.irep_node
-        node = node_for_path(node, starting_at) if starting_at.present?
-
-        generated_includes = if node.present?
-                               resolver.includes_for_node(node, includes)
-                               includes.active_record_includes
-                             end
-
-        instrument[:includes] = generated_includes
-        generated_includes
-      end
-    end
-
-    def self.node_for_path(node, path_into_query)
-      children = node.scoped_children[node.return_type.unwrap]&.with_indifferent_access || {}
-      children.dig(path_into_query)
-    end
-  end
-end
-
-module GraphQL
-  class BaseType
-    def new_define_connection_with_fetched_edge(**kwargs, &block)
-      GraphQLIncludable::New::Relay::EdgeWithNodeConnectionType.create_type(
-        self,
-        **kwargs,
-        &block
-      )
-    end
-  end
-end