graphql_includable 0.3.1 → 0.4.0.alpha.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 9fff2fd1ed83291d757e0d30bd9d5587067764e6
-  data.tar.gz: c09ed087d6aafc20002a6302e1aa4d96dba6744d
+  metadata.gz: 0b4931965d11fc59002d2f514361dc3d30e0a17b
+  data.tar.gz: 2d0d4f23a686bd46d19d3447d989402364f16849
 SHA512:
-  metadata.gz: b8bf0ba1e64f04cddba4379c47da8bd60bef9fa35f099b4ccf364ffa3bd4300af13b341acb486a34d945524475995d8e824ddb4874abe83d7953a89ddaa2e6dc
-  data.tar.gz: 98cfc21bab27745e1f9b5b3496f0906b797df878079c1ef936650296768fd1330e50b8fa63758644aabc03e3fac06f725d74405b28f5d8939f6c0ded6c2dce43
+  metadata.gz: 2be6bc900f6e21eadc3eafda2cf236a35b9d1366e67ace38d392ff4499b3a7bfb50576541edc994e5aa22d0a05018a1d9ba3dae2eef56e28323d8139f27e2ca9
+  data.tar.gz: c42a7b0b009ed5078e786bdbac8e2c25bcd6f192333bc40c02e3d74f96fa373809ddf3aa419be5e28f080a1b9e325574653284921d107a29b578cb56aa3dab23

data/lib/graphql_includable/concern.rb

@@ -6,17 +6,11 @@ module GraphQLIncludable
 
     module ClassMethods
       def includes_from_graphql(ctx)
-        ActiveSupport::Notifications.instrument('graphql_includable.includes_from_graphql') do |instrument|
-          instrument[:operation_name] = ctx.query&.operation_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
+        node = Resolver.find_node_by_return_type(ctx.irep_node, name)
+        manager = IncludesManager.new(nil)
+        Resolver.includes_for_node(node, manager)
+        puts "INCLUDES!!! #{manager.includes}"
+        includes(manager.includes)
       rescue => e
         Rails.logger.error(e)
         self

data/lib/graphql_includable/relay/edge_with_node.rb

@@ -3,8 +3,7 @@ module GraphQLIncludable
     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)
+        node = connection.edge_to_node(@edge)  # TODO: Make lazy
         super(node, connection)
       end
 

data/lib/graphql_includable/relay/edge_with_node_connection.rb

@@ -1,12 +1,17 @@
 module GraphQLIncludable
   module Relay
     class ConnectionEdgesAndNodes
-      attr_reader :parent, :edges_property, :nodes_property
+      attr_reader :parent, :args, :ctx, :edges_property, :nodes_property, :edge_to_node_property, :edges_resolver, :nodes_resolver
 
-      def initialize(parent, edges_property, nodes_property)
+      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
         @nodes_property = nodes_property
+        @edge_to_node_property = edge_to_node_property
+        @edges_resolver = edges_resolver
+        @nodes_resolver = nodes_resolver
       end
     end
 
@@ -23,14 +28,14 @@ module GraphQLIncludable
       end
 
       def fetch_edges
-        @loaded_edges ||= @connection_edges_and_nodes.parent.public_send(@connection_edges_and_nodes.edges_property)
+        @loaded_edges ||= @connection_edges_and_nodes.edges_resolver.call(@connection_edges_and_nodes.parent, args, ctx)
         # 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)
+        @loaded_nodes ||= @connection_edges_and_nodes.nodes_resolver.call(@connection_edges_and_nodes.parent, args, ctx)
         # Set nodes to make underlying BaseConnection work
         @nodes = @loaded_nodes
         @loaded_nodes
@@ -41,8 +46,25 @@ module GraphQLIncludable
         super
       end
 
+      def edge_to_node(edge)
+        edge.public_send(@connection_edges_and_nodes.edge_to_node_property)
+      end
+
+      def total_count
+        @nodes = determin_page_info_nodes
+        @nodes.size
+      end
+
       private
 
+      def args
+        @connection_edges_and_nodes.args
+      end
+
+      def ctx
+        @connection_edges_and_nodes.ctx
+      end
+
       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

data/lib/graphql_includable/relay/edge_with_node_connection_type.rb

@@ -2,7 +2,7 @@ module GraphQLIncludable
   module Relay
     class EdgeWithNodeConnectionType
       def self.create_type(
-        wrapped_type, edge_to_node_property:,
+        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
@@ -10,7 +10,10 @@ module GraphQLIncludable
         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
+
+          field :totalCount, types.Int, "Total count.", property: :total_count
+
+          field :edges, types[edge_type], "A list of edges.", edge_class: custom_edge_class, property: :fetch_edges, _includable_connection_marker: true
 
           if nodes_field
             field :nodes, types[wrapped_type],  "A list of nodes.", property: :fetch_nodes

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

@@ -3,29 +3,65 @@ module GraphQLIncludable
     module Instrumentation
       class Connection
         def instrument(_type, field)
-          return field unless field.connection?
+          return field unless is_edge_with_node_connection?(field)
 
-          required_metadata = [:edges_property, :nodes_property]
-          requires_instrumentation = required_metadata.any? { |key| field.metadata.key?(key) }
+          raise ArgumentError.new('Connection does not support fetching using :property') if field.property.present?
 
-          return field unless requires_instrumentation
-          raise ArgumentError unless required_metadata.all? { |key| field.metadata.key?(key) }
+          validate!(field)
+          edge_to_node_property = field.metadata[:edge_to_node_property]
+          explicit_includes = field.metadata[:includes]
+          edges_prop = explicit_includes[:edges]
+          nodes_prop = explicit_includes[:nodes]
 
-          raise ArgumentError if field.property.present? # TODO: Check for resolve proc too
-
-          edges_prop = field.metadata[:edges_property]
-          nodes_prop = field.metadata[:nodes_property]
+          if is_proc_based?(field)
+            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, edges_prop, nodes_prop)
+            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
+
+        private
+
+        def is_edge_with_node_connection?(field)
+          field.connection? && field.type.fields['edges'].metadata.key?(:_includable_connection_marker)
+        end
+
+        def is_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
+          raise ArgumentError.new("Missing one of #{required_metadata}") unless required_metadata.all? { |key| field.metadata.key?(key) }
+
+          true
+        end
+
+        def validate!(field)
+          raise ArgumentError.new('Missing edge_to_node_property definition for field') unless field.metadata.key?(:edge_to_node_property)
+          raise ArgumentError.new(':edge_to_node_property must be a symbol') unless field.metadata[:edge_to_node_property].is_a?(Symbol)
+
+          raise ArgumentError.new('Missing includes definition for field') unless field.metadata.key?(:includes)
+          includes = field.metadata[:includes]
+          raise ArgumentError.new('Connection includes must be a hash containing :edges and :nodes keys') unless includes.is_a?(Hash)
+          raise ArgumentError.new('Missing :nodes includes') unless includes.key?(:nodes)
+          raise ArgumentError.new('Missing :edges includes') unless includes.key?(:edges)
+          raise ArgumentError.new(':edges must be a symbol') unless includes[:edges].is_a?(Symbol)
+          raise ArgumentError.new(':nodes must be a symbol') unless includes[:edges].is_a?(Symbol)
+        end
       end
 
       GraphQL::Relay::BaseConnection.register_connection_implementation(GraphQLIncludable::Relay::ConnectionEdgesAndNodes, GraphQLIncludable::Relay::EdgeWithNodeConnection)
     end
+
   end
 end

data/lib/graphql_includable/resolver.rb

@@ -80,7 +80,7 @@ module GraphQLIncludable
       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_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
@@ -88,6 +88,7 @@ module GraphQLIncludable
       connection_children = node.scoped_children[node.return_type.unwrap]
       connection_children.each_value do |connection_node|
         # connection_field {
+        #   totalCount
         #   pageInfo {...}
         #   nodes {
         #     node_model_field ...
@@ -122,6 +123,8 @@ module GraphQLIncludable
           node_children.each_value do |node_child_node|
             includes_for_child(node_child_node, node_model, nodes_includes_manager)
           end
+        elsif connection_node.name == 'totalCount'
+          # Handled using `.size` - if includes() grabbed edges/nodes it will .length else, a COUNT query saving memory.
         end
       end
     end
@@ -167,15 +170,16 @@ module GraphQLIncludable
 
     def self.node_possible_association_names(node)
       definition = node.definitions.first
+      user_includes = definition.metadata[:includes]
 
       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.
+        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
       end
 
-      association_names[:default] = definition.metadata[:includes] || (definition.property || definition.name).to_sym
+      association_names[:default] = user_includes || (definition.property || definition.name).to_sym
       association_names
     end
 

data/lib/graphql_includable.rb

@@ -9,9 +9,11 @@ require 'graphql_includable/relay/instrumentation/connection'
 
 GraphQL::Field.accepts_definitions(
   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)
+  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 GraphQL

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: graphql_includable
 version: !ruby/object:Gem::Version
-  version: 0.3.1
+  version: 0.4.0.alpha.1
 platform: ruby
 authors:
 - Dan Rouse
@@ -10,7 +10,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-08-15 00:00:00.000000000 Z
+date: 2019-08-06 00:00:00.000000000 Z
 dependencies: []
 description: 
 email:
@@ -44,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