graphql_includable 0.5.0 → 1.0.0.beta.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 014b367c0c9e017f33db0076bc473668d2033caa
-  data.tar.gz: 61b6f1699b9d77c9ca3745be27a5f8f9b5da4e22
+  metadata.gz: c8ee024cd716dce8f0dee9b91066c089ba8ffab7
+  data.tar.gz: 5c6b1fb71d7c754f3f94285bf9571c72583667ec
 SHA512:
-  metadata.gz: 50ea6afd3369d545c9ad72574a513c3f4de81a753cc1ab15b5cdeaea3375d7f9548f2586bb9717b6e974558126bdc87e605fe50739e3fbccaaf8c2bb9e2b1c84
-  data.tar.gz: c32ad015198ced702ab16964905808abf86b632406e4f6acf2e9583f0c8ecfa4ce2dc00d30a5fe6b620e01db8c66c504f3b38256ae41a9c7a4c1222c45d62fa1
+  metadata.gz: 8cf0f027b8cf3a042053bfec69b180e5063e15df750f8e07b7c66c2d187ba3a26c25c8efb5231226ed2bacb814293660426ebca41af8bfff52c310d024bd3ec4
+  data.tar.gz: 402967a9b2a4d9675a718f8aed1314cfaf5793dade58ebe7e645ede3ab702a50ee2f18846ca10c89b64a33927d208c30bc70cde5c3c07da4a46b281e8f84a370

data/lib/graphql_includable/includes.rb

@@ -0,0 +1,67 @@
+module GraphQLIncludable
+  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 dig(*args)
+      args = args[0] if args.length == 1 && args[0].is_a?(Array)
+      return @included_children if args.empty?
+      @included_children.dig(*args)
+    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

data/lib/graphql_includable/includes_builder.rb

@@ -0,0 +1,108 @@
+module GraphQLIncludable
+  class IncludesBuilder
+    attr_reader :included_path, :includes
+
+    def initialize(only_one_path: true)
+      @only_one_path = only_one_path
+      @included_path = []
+      @includes = GraphQLIncludable::Includes.new(nil)
+    end
+
+    def includes?
+      @included_path.present?
+    end
+
+    def active_record_includes
+      @includes.active_record_includes
+    end
+
+    def path_leaf_includes
+      @includes.dig(included_path)
+    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::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::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

data/lib/graphql_includable/relay/edge_with_node.rb

@@ -1,10 +1,33 @@
+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
+  _includable_connection_marker: GraphQL::Define.assign_metadata_key(:_includable_connection_marker)
+)
+
 module GraphQLIncludable
   module Relay
     class EdgeWithNode < GraphQL::Relay::Edge
       def initialize(node, connection)
         @edge = node
-        node = connection.edge_to_node(@edge) # TODO: Make lazy
-        super(node, connection)
+        @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)

data/lib/graphql_includable/relay/edge_with_node_connection.rb

@@ -11,8 +11,8 @@ module GraphQLIncludable
         @parent = parent
         @args = args
         @ctx = ctx
-        @edges_property = edges_property
-        @nodes_property = nodes_property
+        @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
@@ -33,14 +33,20 @@ module GraphQLIncludable
       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
@@ -76,11 +82,15 @@ module GraphQLIncludable
         return @loaded_nodes if @loaded_nodes.present?
         return @loaded_edges if @loaded_edges.present?
 
-        nodes_preloaded = @edges_and_nodes.parent.association(@edges_and_nodes.nodes_property).loaded?
-        return fetch_nodes if nodes_preloaded
+        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
 
-        edges_preloaded = @edges_and_nodes.parent.association(@edges_and_nodes.edges_property).loaded?
-        return fetch_edges if edges_preloaded
+        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

data/lib/graphql_includable/relay/edge_with_node_connection_type.rb

@@ -1,3 +1,5 @@
+require_relative 'edge_with_node'
+
 module GraphQLIncludable
   module Relay
     class EdgeWithNodeConnectionType

data/lib/graphql_includable/relay/instrumentation.rb

@@ -0,0 +1,77 @@
+require_relative 'edge_with_node_connection'
+
+module GraphQLIncludable
+  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?(:_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::Relay::ConnectionEdgesAndNodes,
+      GraphQLIncludable::Relay::EdgeWithNodeConnection
+    )
+  end
+end