graphql_includable 0.4.0 → 0.5.0.beta.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: c26fc967e743b93dc24703e364dc4500f17d94b9
-  data.tar.gz: 2c63040e1ed7695b36c9911fd44f6892d9c48c8f
+  metadata.gz: 21738d44c97c02d307c624f23191471f5701e078
+  data.tar.gz: acacb75291ee29bc5356b577ba2df1e9933ae8ca
 SHA512:
-  metadata.gz: 7fda91af53b2e1057d0eb3acdaa251bda2b96b394f69445c309fe388a79ef6b0f4db76e694af58083b64676d5ced3a291fcbd82a3ad62064025637d08cd09e7d
-  data.tar.gz: 294fcbba508907345fc91a672e55a8305ff9702a89b0b34cbb0f397dbf64b15ef20fcb230c11ecf72281a6e12db4b7aafdcab0a5be554868e2410dee22844ba4
+  metadata.gz: 0d63dae811fa795631ab1fc7a996421c7113f72c97151fadd17dc1e76c3c9ce8ca61c8262fde791105cadd2bfb6281a2f4575d6b9645c4e09bc1648d66bd8638
+  data.tar.gz: da84988546493f2decef19b3b8bc92b1d02c27a1876c85b59b49e7d650d8e960500b21e85272f3dd996a9aa798e00b72d71db64062a40bc70dbd1f0b26cdd881

data/lib/graphql_includable/concern.rb

@@ -6,10 +6,18 @@ module GraphQLIncludable
 
     module ClassMethods
       def includes_from_graphql(ctx)
-        node = Resolver.find_node_by_return_type(ctx.irep_node, name)
-        manager = IncludesManager.new(nil)
-        Resolver.includes_for_node(node, manager)
-        includes(manager.includes)
+        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

data/lib/graphql_includable/edge.rb

@@ -1,22 +1,33 @@
 # 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)
 
-      root_association_key = class_to_str(parent.class)
+      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])
+      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
@@ -65,10 +76,14 @@ module GraphQLIncludable
       # 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])
+      if parent.instance_of?(GraphQLIncludable::New::Relay::LazyEvaluatedNode)
+        parent_class = parent._value.class
       else
-        parent_class = parent.class
+        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 = []

data/lib/graphql_includable/new/gql_includable.rb

@@ -0,0 +1,36 @@
+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)
+      ActiveSupport::Notifications.instrument('graphql_includable.includes') do |instrument|
+        instrument[:operation_name] = ctx.query&.operation_name
+        instrument[:field_name] = ctx.irep_node.name
+
+        includes = Includes.new(nil)
+        resolver = Resolver.new(ctx)
+        resolver.includes_for_node(ctx.irep_node, includes)
+        generated_includes = includes.active_record_includes
+        instrument[:includes] = generated_includes
+        generated_includes
+      end
+    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

data/lib/graphql_includable/new/includes.rb

@@ -0,0 +1,63 @@
+module GraphQLIncludable
+  module New
+    class Includes
+      attr_reader :included_children
+
+      def initialize(parent_attribute)
+        @parent_attribute = parent_attribute
+        @included_children = {}
+      end
+
+      def add_child(key)
+        return @included_children[key] if @included_children.key?(key)
+        manager = Includes.new(key)
+        @included_children[key] = manager
+        manager
+      end
+
+      def merge_includes(includes_manager)
+        includes_manager.included_children.each do |key, manager|
+          included_children[key] = if included_children.key?(key)
+                                     included_children[key].merge_includes(manager)
+                                   else
+                                     manager
+                                   end
+        end
+        self
+      end
+
+      def [](key)
+        @included_children[key]
+      end
+
+      def empty?
+        @included_children.empty?
+      end
+
+      def active_record_includes
+        child_includes = {}
+        child_includes_arr = []
+        @included_children.each do |key, value|
+          if value.empty?
+            child_includes_arr << key
+          else
+            active_record_includes = value.active_record_includes
+            if active_record_includes.is_a?(Array)
+              child_includes_arr += active_record_includes
+            else
+              child_includes.merge!(active_record_includes)
+            end
+          end
+        end
+
+        if child_includes_arr.present?
+          child_includes_arr << child_includes if child_includes.present?
+          child_includes = child_includes_arr
+        end
+
+        return child_includes if @parent_attribute.nil?
+        { @parent_attribute => child_includes }
+      end
+    end
+  end
+end

data/lib/graphql_includable/new/includes_builder.rb

@@ -0,0 +1,114 @@
+module GraphQLIncludable
+  module New
+    class IncludesBuilder
+      attr_reader :included_path, :includes
+
+      def initialize(only_one_path: true)
+        @only_one_path = only_one_path
+        @included_path = []
+        @includes = GraphQLIncludable::New::Includes.new(nil)
+      end
+
+      def includes?
+        @included_path.present?
+      end
+
+      def active_record_includes
+        @includes.active_record_includes
+      end
+
+      def path_leaf_includes
+        leaf_includes = @includes
+        included_path.each do |key|
+          leaf_includes = leaf_includes[key]
+        end
+        leaf_includes
+      end
+
+      def path(*symbols, &block)
+        raise ArgumentError, 'Can only add path once' if @included_path.present? && @only_one_path
+
+        if symbols.present?
+          first, *rest = symbols
+          includes = @includes.add_child(first)
+          rest.each do |key|
+            includes = includes.add_child(key)
+          end
+        else
+          includes = @includes
+        end
+
+        if block_given?
+          nested = GraphQLIncludable::New::IncludesBuilder.new
+          nested.instance_eval(&block)
+          symbols += nested.included_path
+          includes.merge_includes(nested.includes)
+        end
+        @included_path = symbols
+      end
+
+      def sibling_path(*symbols, &block)
+        if symbols.present?
+          first, *rest = symbols
+          includes = @includes.add_child(first)
+          rest.each do |key|
+            includes = includes.add_child(key)
+          end
+        else
+          includes = @includes
+        end
+
+        return unless block_given?
+        nested = GraphQLIncludable::New::IncludesBuilder.new(only_one_path: false)
+        nested.instance_eval(&block)
+        includes.merge_includes(nested.includes)
+      end
+    end
+
+    class ConnectionIncludesBuilder
+      attr_reader :nodes_builder, :edges_builder
+
+      def initialize
+        @nodes_builder = IncludesBuilder.new
+        @edges_builder = ConnectionEdgesIncludesBuilder.new
+      end
+
+      def includes?
+        @nodes_builder.includes? || @edges_builder.includes?
+      end
+
+      def nodes(*symbols, &block)
+        @nodes_builder.path(*symbols, &block)
+      end
+
+      def edges(&block)
+        @edges_builder.instance_eval(&block)
+      end
+    end
+
+    class ConnectionEdgesIncludesBuilder
+      attr_reader :builder, :node_builder
+
+      def initialize
+        @builder = IncludesBuilder.new
+        @node_builder = IncludesBuilder.new
+      end
+
+      def includes?
+        @builder.includes? && @node_builder.includes?
+      end
+
+      def path(*symbols, &block)
+        @builder.path(*symbols, &block)
+      end
+
+      def sibling_path(*symbols, &block)
+        @builder.sibling_path(*symbols, &block)
+      end
+
+      def node(*symbols, &block)
+        @node_builder.path(*symbols, &block)
+      end
+    end
+  end
+end

data/lib/graphql_includable/new/relay/edge_with_node.rb

@@ -0,0 +1,48 @@
+GraphQL::Field.accepts_definitions(
+  ##
+  # Define how to get from an edge Active Record model to the node Active Record model
+  connection_properties: GraphQL::Define.assign_metadata_key(:connection_properties),
+
+  ##
+  # Define a resolver for connection edges records
+  resolve_edges: GraphQL::Define.assign_metadata_key(:resolve_edges),
+
+  ##
+  # Define a resolver for connection nodes records
+  resolve_nodes: GraphQL::Define.assign_metadata_key(:resolve_nodes),
+
+  ##
+  # Internally used to mark a connection type that has a fetched edge
+  _new_includable_connection_marker: GraphQL::Define.assign_metadata_key(:_new_includable_connection_marker)
+)
+
+module GraphQLIncludable
+  module New
+    module Relay
+      class EdgeWithNode < GraphQL::Relay::Edge
+        def initialize(node, connection)
+          @edge = node
+          @edge_to_node = ->() { connection.edge_to_node(@edge) }
+          super(nil, connection)
+        end
+
+        def node
+          @node ||= @edge_to_node.call
+          @node
+        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
+      end
+    end
+  end
+end

data/lib/graphql_includable/new/relay/edge_with_node_connection.rb

@@ -0,0 +1,101 @@
+module GraphQLIncludable
+  module New
+    module Relay
+      class ConnectionEdgesAndNodes
+        attr_reader :parent, :args, :ctx, :edges_property, :nodes_property, :edge_to_node_property
+        attr_reader :edges_resolver, :nodes_resolver
+
+        # rubocop:disable Metrics/ParameterLists
+        def initialize(parent, args, ctx,
+                       edges_property, nodes_property, edge_to_node_property,
+                       edges_resolver, nodes_resolver)
+          @parent = parent
+          @args = args
+          @ctx = ctx
+          @edges_property = edges_property # optional
+          @nodes_property = nodes_property # optional
+          @edge_to_node_property = edge_to_node_property
+          @edges_resolver = edges_resolver
+          @nodes_resolver = nodes_resolver
+        end
+        # rubocop:enable Metrics/ParameterLists
+      end
+
+      class EdgeWithNodeConnection < GraphQL::Relay::RelationConnection
+        def initialize(nodes, *args, &block)
+          @edges_and_nodes = nodes
+          @loaded_nodes = nil
+          @loaded_edges = nil
+          super(nil, *args, &block)
+        end
+
+        def edge_nodes
+          raise 'This should not be called from a EdgeWithNodeConnectionType'
+        end
+
+        def fetch_edges
+          # This context is used within Resolver for connections
+          ctx.namespace(:gql_includable)[:resolving] = :edges
+          @loaded_edges ||= @edges_and_nodes.edges_resolver.call(@edges_and_nodes.parent, args, ctx)
+          ctx.namespace(:gql_includable)[:resolving] = nil
+          # Set nodes to make underlying BaseConnection work
+          @nodes = @loaded_edges
+          @loaded_edges
+        end
+
+        def fetch_nodes
+          # This context is used within Resolver for connections
+          ctx.namespace(:gql_includable)[:resolving] = :nodes
+          @loaded_nodes ||= @edges_and_nodes.nodes_resolver.call(@edges_and_nodes.parent, args, ctx)
+          ctx.namespace(:gql_includable)[:resolving] = nil
+          # Set nodes to make underlying BaseConnection work
+          @nodes = @loaded_nodes
+          @loaded_nodes
+        end
+
+        def page_info
+          @nodes = determine_page_info_nodes
+          super
+        end
+
+        def edge_to_node(edge)
+          edge.public_send(@edges_and_nodes.edge_to_node_property)
+        end
+
+        def total_count
+          @nodes = determine_page_info_nodes
+          @nodes.size
+        end
+
+        private
+
+        def args
+          @edges_and_nodes.args
+        end
+
+        def ctx
+          @edges_and_nodes.ctx
+        end
+
+        def determine_page_info_nodes
+          # If the query asks for `pageInfo` before `edges` or `nodes`, we dont directly know which to use most
+          # efficently. We can have a guess by checking if either of the associations are preloaded
+          return @loaded_nodes if @loaded_nodes.present?
+          return @loaded_edges if @loaded_edges.present?
+
+          if @edges_and_nodes.nodes_property.present?
+            nodes_preloaded = @edges_and_nodes.parent.association(@edges_and_nodes.nodes_property).loaded?
+            return fetch_nodes if nodes_preloaded
+          end
+
+          if @edges_and_nodes.edges_property.present?
+            edges_preloaded = @edges_and_nodes.parent.association(@edges_and_nodes.edges_property).loaded?
+            return fetch_edges if edges_preloaded
+          end
+
+          fetch_nodes
+        end
+      end
+    end
+  end
+end

data/lib/graphql_includable/new/relay/edge_with_node_connection_type.rb

@@ -0,0 +1,37 @@
+require_relative 'edge_with_node'
+
+module GraphQLIncludable
+  module New
+    module Relay
+      class EdgeWithNodeConnectionType
+        def self.create_type(
+          wrapped_type,
+          edge_type: wrapped_type.edge_type, edge_class: EdgeWithNode,
+          nodes_field: GraphQL::Relay::ConnectionType.default_nodes_field, &block
+        )
+          custom_edge_class = edge_class
+
+          GraphQL::ObjectType.define do
+            name("#{wrapped_type.name}Connection")
+            description("The connection type for #{wrapped_type.name}.")
+
+            field :totalCount, types.Int, 'Total count.', property: :total_count
+
+            field :edges, types[edge_type], 'A list of edges.' do
+              edge_class custom_edge_class
+              property :fetch_edges
+              _new_includable_connection_marker true
+            end
+
+            if nodes_field
+              field :nodes, types[wrapped_type], 'A list of nodes.', property: :fetch_nodes
+            end
+
+            field :pageInfo, !GraphQL::Relay::PageInfo, 'Information to aid in pagination.', property: :page_info
+            block && instance_eval(&block)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/graphql_includable/new/relay/instrumentation.rb

@@ -0,0 +1,79 @@
+require_relative 'edge_with_node_connection'
+
+module GraphQLIncludable
+  module New
+    module Relay
+      class Instrumentation
+        # rubocop:disable Metrics/AbcSize
+        def instrument(_type, field)
+          return field unless edge_with_node_connection?(field)
+
+          raise ArgumentError, 'Connection does not support fetching using :property' if field.property.present?
+
+          is_proc_based = proc_based?(field)
+
+          validate!(field, is_proc_based)
+          properties = field.metadata[:connection_properties]
+          edge_to_node_property = properties[:edge_to_node]
+          edges_prop = properties[:edges]
+          nodes_prop = properties[:nodes]
+
+          if is_proc_based
+            edges_resolver = field.metadata[:resolve_edges]
+            nodes_resolver = field.metadata[:resolve_nodes]
+          else
+            # Use the edges and nodes symbols from the incldues pattern as the propeties to fetch
+            edges_resolver = ->(obj, _args, _ctx) { obj.public_send(edges_prop) }
+            nodes_resolver = ->(obj, _args, _ctx) { obj.public_send(nodes_prop) }
+          end
+
+          _original_resolve = field.resolve_proc
+          new_resolve_proc = ->(obj, args, ctx) do
+            ConnectionEdgesAndNodes.new(obj, args, ctx,
+                                        edges_prop, nodes_prop, edge_to_node_property,
+                                        edges_resolver, nodes_resolver)
+          end
+
+          field.redefine { resolve(new_resolve_proc) }
+        end
+        # rubocop:enable Metrics/AbcSize
+
+        private
+
+        def edge_with_node_connection?(field)
+          field.connection? && field.type.fields['edges'].metadata.key?(:_new_includable_connection_marker)
+        end
+
+        def proc_based?(field)
+          required_metadata = [:resolve_edges, :resolve_nodes]
+          has_a_resolver = required_metadata.any? { |key| field.metadata.key?(key) }
+
+          return false unless has_a_resolver
+          unless required_metadata.all? { |key| field.metadata.key?(key) }
+            raise ArgumentError, "Missing one of #{required_metadata}"
+          end
+
+          true
+        end
+
+        def validate!(field, is_proc_based)
+          unless field.metadata.key?(:connection_properties)
+            raise ArgumentError, 'Missing connection_properties definition for field'
+          end
+          properties = field.metadata[:connection_properties]
+          unless properties.is_a?(Hash)
+            raise ArgumentError, 'Connection includes must be a hash containing :edges and :nodes keys'
+          end
+          raise ArgumentError, 'Missing :nodes' unless is_proc_based || properties.key?(:nodes)
+          raise ArgumentError, 'Missing :edges' unless is_proc_based || properties.key?(:edges)
+          raise ArgumentError, 'Missing :edge_to_node' unless properties.key?(:edge_to_node)
+        end
+      end
+
+      GraphQL::Relay::BaseConnection.register_connection_implementation(
+        GraphQLIncludable::New::Relay::ConnectionEdgesAndNodes,
+        GraphQLIncludable::New::Relay::EdgeWithNodeConnection
+      )
+    end
+  end
+end

data/lib/graphql_includable/new/resolver.rb

@@ -0,0 +1,177 @@
+GraphQL::Field.accepts_definitions(
+  ##
+  # Define Active Record includes for a field
+  new_includes: GraphQL::Define.assign_metadata_key(:new_includes)
+)
+
+module GraphQLIncludable
+  module New
+    class Resolver
+      def initialize(ctx)
+        @root_ctx = ctx
+      end
+
+      def includes_for_node(node, includes)
+        return includes_for_top_level_connection(node, includes) if node.definition.connection?
+
+        children = node.scoped_children[node.return_type.unwrap]
+        children.each_value do |child_node|
+          includes_for_child(child_node, includes)
+        end
+      end
+
+      private
+
+      def includes_for_child(node, includes)
+        return includes_for_connection(node, includes) if node.definition.connection?
+
+        builder = build_includes(node)
+        return unless builder&.includes?
+
+        includes.merge_includes(builder.includes)
+
+        # Determine which [nested] child Includes manager to send to the children
+        child_includes = builder.path_leaf_includes
+
+        children = node.scoped_children[node.return_type.unwrap]
+        children.each_value do |child_node|
+          includes_for_child(child_node, child_includes)
+        end
+      end
+
+      # rubocop:disable Metrics/AbcSize
+      # rubocop:disable Metrics/MethodLength
+      def includes_for_connection(node, includes)
+        builder = build_connection_includes(node)
+        return unless builder&.includes?
+
+        connection_children = node.scoped_children[node.return_type.unwrap]
+        connection_children.each_value do |connection_node|
+          # connection_field {
+          #   totalCount
+          #   pageInfo {...}
+          #   nodes {
+          #     node_model_field ...
+          #   }
+          #   edges {
+          #     edge_model_field ...
+          #     node {
+          #       node_model_field ...
+          #     }
+          #   }
+          # }
+
+          if connection_node.name == 'edges'
+            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_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, edge_node_includes)
+                end
+              else
+                includes_for_child(edge_child_node, edges_includes)
+              end
+            end
+          elsif connection_node.name == 'nodes'
+            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, nodes_includes)
+            end
+          elsif connection_node.name == 'totalCount'
+            # Handled using `.size`
+          end
+        end
+      end
+
+      # 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)
+          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|
+                includes_for_child(node_child_node, edge_node_includes)
+              end
+            else
+              includes_for_child(edge_child_node, edges_includes)
+            end
+          end
+        else
+          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|
+            includes_for_child(node_child_node, nodes_includes)
+          end
+        end
+      end
+      # rubocop:enable Metrics/MethodLength
+      # rubocop:enable Metrics/AbcSize
+
+      def build_includes(node)
+        includes_meta = node.definition.metadata[:new_includes]
+        return nil if includes_meta.blank?
+
+        builder = GraphQLIncludable::New::IncludesBuilder.new
+
+        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
+
+        builder
+      end
+
+      def build_connection_includes(node)
+        includes_meta = node.definition.metadata[:new_includes]
+        return nil if includes_meta.blank?
+
+        builder = GraphQLIncludable::New::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
+        builder
+      end
+    end
+  end
+end

data/lib/graphql_includable/relay/edge_with_node_connection.rb

@@ -47,7 +47,7 @@ module GraphQLIncludable
       end
 
       def page_info
-        @nodes = determin_page_info_nodes
+        @nodes = determine_page_info_nodes
         super
       end
 
@@ -56,7 +56,7 @@ module GraphQLIncludable
       end
 
       def total_count
-        @nodes = determin_page_info_nodes
+        @nodes = determine_page_info_nodes
         @nodes.size
       end
 
@@ -70,7 +70,7 @@ module GraphQLIncludable
         @edges_and_nodes.ctx
       end
 
-      def determin_page_info_nodes
+      def determine_page_info_nodes
         # If the query asks for `pageInfo` before `edges` or `nodes`, we dont directly know which to use most
         # efficently. We can have a guess by checking if either of the associations are preloaded
         return @loaded_nodes if @loaded_nodes.present?

data/lib/graphql_includable.rb

@@ -6,6 +6,7 @@ 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'
 
 GraphQL::Field.accepts_definitions(
   includes: GraphQL::Define.assign_metadata_key(:includes),

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: graphql_includable
 version: !ruby/object:Gem::Version
-  version: 0.4.0
+  version: 0.5.0.beta.1
 platform: ruby
 authors:
 - Dan Rouse
@@ -10,7 +10,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-08-07 00:00:00.000000000 Z
+date: 2019-08-28 00:00:00.000000000 Z
 dependencies: []
 description: 
 email:
@@ -24,6 +24,14 @@ 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/relay/edge_with_node.rb
 - lib/graphql_includable/relay/edge_with_node_connection.rb
 - lib/graphql_includable/relay/edge_with_node_connection_type.rb
@@ -44,9 +52,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