graphql_includable 0.2.12 → 0.3.0.alpha.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 7e15a080b64989dcfc9dfb9e9df39cf8f37c96ee
-  data.tar.gz: c0c53dcc1a61dbaab44b9c585bb5a486d0d1223b
+  metadata.gz: e012854a25b8c65723c9903dda037159e41999e1
+  data.tar.gz: bb0ae8ce407dc874d6ae8c9361cab4ca6010af0b
 SHA512:
-  metadata.gz: c7d535ba4e020ff2eac12c1aa81f63de740af241dfc3b1669167667afb8bf8ed6ca1edd8d761b37f847555d03a64e8c23691a91b857a93e0c985d561a0a091b1
-  data.tar.gz: 320b95f48de65e16b42033b2ef45cd921d86c57e70e98ada5600155d7204a912665db781203f090d011d4b83ed8e871825a751c43491efc427a79232f2507387
+  metadata.gz: d2aee7ee36e05bc87d308f4576fb48ac0205105e612ee2ee140865bb54dae043376bec46af4d237992fce32eec5a9ecb248b70e7db8aeafb653b0c299bd53690
+  data.tar.gz: a014ad366b299f89037d0fad3e0d6b1a87d614f71c691696b55bbd7ea1a4a34ab36969ed79b0db5fdb93be50d11427c5126a477c9f8b2e7db199c3495cc59869

data/lib/graphql_includable/concern.rb

@@ -7,9 +7,9 @@ module GraphQLIncludable
     module ClassMethods
       def includes_from_graphql(ctx)
         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)
+        manager = IncludesManager.new(nil)
+        Resolver.includes_for_node(node, manager)
+        includes(manager.includes)
       rescue => e
         Rails.logger.error(e)
         self

data/lib/graphql_includable/relay/edge_with_node.rb

@@ -0,0 +1,24 @@
+module GraphQLIncludable
+  module Relay
+    class EdgeWithNode < GraphQL::Relay::Edge
+      def initialize(node, connection)
+        @edge = node
+        edge_to_node_property = connection.field.type.fields['edges'].metadata[:edge_to_node_property]
+        node = @edge.public_send(edge_to_node_property)
+        super(node, connection)
+      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

data/lib/graphql_includable/relay/edge_with_node_connection.rb

@@ -0,0 +1,62 @@
+module GraphQLIncludable
+  module Relay
+    class ConnectionEdgesAndNodes
+      attr_reader :parent, :edges_property, :nodes_property
+
+      def initialize(parent, edges_property, nodes_property)
+        @parent = parent
+        @edges_property = edges_property
+        @nodes_property = nodes_property
+      end
+    end
+
+    class EdgeWithNodeConnection < GraphQL::Relay::RelationConnection
+      def initialize(nodes, *args, &block)
+        @connection_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
+        @loaded_edges ||= @connection_edges_and_nodes.parent.public_send(@connection_edges_and_nodes.edges_property)
+        # Set nodes to make underlying BaseConnection work
+        @nodes = @loaded_edges
+        @loaded_edges
+      end
+
+      def fetch_nodes
+        @loaded_nodes ||= @connection_edges_and_nodes.parent.public_send(@connection_edges_and_nodes.nodes_property)
+        # Set nodes to make underlying BaseConnection work
+        @nodes = @loaded_nodes
+        @loaded_nodes
+      end
+
+      def page_info
+        @nodes = determin_page_info_nodes
+        super
+      end
+
+      private
+
+      def determin_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?
+
+        nodes_preloaded = @connection_edges_and_nodes.parent.association(@connection_edges_and_nodes.nodes_property).loaded?
+        return fetch_nodes if nodes_preloaded
+
+        edges_preloaded = @connection_edges_and_nodes.parent.association(@connection_edges_and_nodes.edges_property).loaded?
+        return fetch_edges if edges_preloaded
+
+        fetch_nodes
+      end
+    end
+  end
+end

data/lib/graphql_includable/relay/edge_with_node_connection_type.rb

@@ -0,0 +1,25 @@
+module GraphQLIncludable
+  module Relay
+    class EdgeWithNodeConnectionType
+      def self.create_type(
+        wrapped_type, edge_to_node_property:,
+        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 :edges, types[edge_type], "A list of edges.", edge_class: custom_edge_class, property: :fetch_edges, edge_to_node_property: edge_to_node_property
+
+          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

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

@@ -0,0 +1,31 @@
+module GraphQLIncludable
+  module Relay
+    module Instrumentation
+      class Connection
+        def instrument(_type, field)
+          return field unless field.connection?
+
+          required_metadata = [:edges_property, :nodes_property]
+          requires_instrumentation = required_metadata.any? { |key| field.metadata.key?(key) }
+
+          return field unless requires_instrumentation
+          raise ArgumentError unless required_metadata.all? { |key| field.metadata.key?(key) }
+
+          raise ArgumentError if field.property.present? # TODO: Check for resolve proc too
+
+          edges_prop = field.metadata[:edges_property]
+          nodes_prop = field.metadata[:nodes_property]
+
+          _original_resolve = field.resolve_proc
+          new_resolve_proc = ->(obj, args, ctx) do
+            ConnectionEdgesAndNodes.new(obj, edges_prop, nodes_prop)
+          end
+
+          field.redefine { resolve(new_resolve_proc) }
+        end
+      end
+
+      GraphQL::Relay::BaseConnection.register_connection_implementation(GraphQLIncludable::Relay::ConnectionEdgesAndNodes, GraphQLIncludable::Relay::EdgeWithNodeConnection)
+    end
+  end
+end

data/lib/graphql_includable/resolver.rb

@@ -1,4 +1,48 @@
 module GraphQLIncludable
+  class IncludesManager
+    def initialize(parent_attribute)
+      @parent_attribute = parent_attribute
+      @included_children = {}
+    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 empty?
+      @included_children.empty?
+    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
+
+      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
+
   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)
@@ -19,52 +63,80 @@ module GraphQLIncludable
     # 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)
+    def self.includes_for_node(node, includes_manager)
       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)
+        includes_for_child(child_node, return_model, includes_manager)
+      end
+    end
 
-        if child_includes.is_a?(Hash)
-          nested_includes.merge!(child_includes)
-        elsif child_includes.is_a?(Array)
-          includes += child_includes
-        else
-          includes << child_includes
+    def self.includes_from_connection(node, parent_model, associations_from_parent_model, includes_manager)
+      return unless node.return_type.fields['edges'].edge_class <= GraphQLIncludable::Relay::EdgeWithNode  # TODO: Possibly basic support for connections with only nodes
+
+      edges_association = associations_from_parent_model[:edges]
+      nodes_association = associations_from_parent_model[:nodes]
+
+      edge_node_attribute = node.return_type.fields['edges'].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
+
+      connection_children = node.scoped_children[node.return_type.unwrap]
+      connection_children.each_value do |connection_node|
+        # connection_field {
+        #   pageInfo {...}
+        #   nodes {
+        #     node_model_field ...
+        #   }
+        #   edges {
+        #     edge_model_field ...
+        #     node {
+        #       node_model_field ...
+        #     }
+        #   }
+        # }
+
+        if connection_node.name == 'edges'
+          edges_includes_manager = includes_manager.add_child_include(edges_association)
+
+          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_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)
+              end
+            else
+              includes_for_child(edge_child_node, edge_model, edges_includes_manager)
+            end
+          end
+        elsif connection_node.name == 'nodes'
+          nodes_includes_manager = includes_manager.add_child_include(nodes_association)
+          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)
+          end
         end
       end
-
-      includes << nested_includes if nested_includes.present?
-      includes.uniq
     end
 
-    def self.includes_for_child(node, parent_model)
-      attribute_name = node_predicted_association_name(node)
-      delegated_through = includes_delegated_through(parent_model, attribute_name)
-      delegated_model = model_name_to_class(delegated_through.last) if delegated_through.present?
-      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?)
+    def self.includes_for_child(node, parent_model, includes_manager)
+      associations = possible_associations(node, parent_model)
+
+      if associations.present?
+        if node_is_relay_connection?(node)
+          includes_from_connection(node, parent_model, associations, includes_manager)
+        else
+          association = associations[:default] # should only be one
+          child_includes_manager = includes_manager.add_child_include(association)
+          includes_for_node(node, child_includes_manager)
+        end
       end
     end
 
@@ -84,9 +156,34 @@ module GraphQLIncludable
     rescue NameError
     end
 
-    def self.node_predicted_association_name(node)
+    def self.node_is_relay_connection?(node)
+      node.return_type.unwrap.name =~ /Connection$/
+    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
+    end
+
+    def self.node_possible_association_names(node)
       definition = node.definitions.first
-      definition.metadata[:includes] || (definition.property || definition.name).to_sym
+
+      association_names = {}
+      if node_is_relay_connection?(node)
+        association_names[:edges] = definition.metadata[:edges_property] if definition.metadata.key?(:edges_property)
+        association_names[:nodes] = definition.metadata[:nodes_property] if definition.metadata.key?(:nodes_property)
+        return association_names if association_names.present? # This should be an includable connection with no :property or name fallback.
+      end
+
+      association_names[:default] = definition.metadata[:includes] || (definition.property || definition.name).to_sym
+      association_names
+    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
@@ -102,14 +199,5 @@ module GraphQLIncludable
       end
       chain
     end
-
-    # Right-reduce an array into a nested hash
-    def self.array_to_nested_hash(arr)
-      arr.reverse.inject { |acc, item| { item => acc } } || {}
-    end
-
-    # def self.node_is_relay_connection?(node)
-    #   node.return_type.unwrap.name =~ /Connection$/
-    # end
   end
 end

data/lib/graphql_includable.rb

@@ -2,19 +2,35 @@ 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'
 
 GraphQL::Field.accepts_definitions(
-  includes: GraphQL::Define.assign_metadata_key(:includes)
+  includes: GraphQL::Define.assign_metadata_key(:includes),
+  edges_property: GraphQL::Define.assign_metadata_key(:edges_property),
+  nodes_property: GraphQL::Define.assign_metadata_key(:nodes_property),
+  edge_to_node_property: GraphQL::Define.assign_metadata_key(:edge_to_node_property)
 )
 
 module GraphQL
   class BaseType
     def define_includable_connection(**kwargs, &block)
+      warn '[DEPRECATION] `define_includable_connection` is deprecated.  Please use `define_connection_with_fetched_edge` instead.'
       define_connection(
         edge_class: GraphQLIncludable::Edge,
         **kwargs,
         &block
       )
     end
+
+    def define_connection_with_fetched_edge(**kwargs, &block)
+      GraphQLIncludable::Relay::EdgeWithNodeConnectionType.create_type(
+        self,
+        **kwargs,
+        &block
+      )
+    end
   end
 end

metadata

@@ -1,20 +1,22 @@
 --- !ruby/object:Gem::Specification
 name: graphql_includable
 version: !ruby/object:Gem::Version
-  version: 0.2.12
+  version: 0.3.0.alpha.1
 platform: ruby
 authors:
 - Dan Rouse
 - Josh Vickery
+- Jordan Hamill
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-06-25 00:00:00.000000000 Z
+date: 2019-08-05 00:00:00.000000000 Z
 dependencies: []
 description: 
 email:
 - dan.rouse@squarefoot.com
 - jvickery@squarefoot.com
+- jordan@squarefoot.com
 executables: []
 extensions: []
 extra_rdoc_files: []
@@ -22,6 +24,10 @@ files:
 - lib/graphql_includable.rb
 - lib/graphql_includable/concern.rb
 - lib/graphql_includable/edge.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/resolver.rb
 homepage: https://github.com/thesquarefoot/graphql_includable
 licenses:
@@ -38,12 +44,12 @@ 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.11
+rubygems_version: 2.6.14.1
 signing_key: 
 specification_version: 4
 summary: An ActiveSupport::Concern for GraphQL Ruby to eager-load query data