graphql_includable 0.5.0 → 1.0.0.beta.0

data/lib/graphql_includable/new/includes.rb

@@ -1,69 +0,0 @@
-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 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
-end

data/lib/graphql_includable/new/includes_builder.rb

@@ -1,110 +0,0 @@
-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
-        @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::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

@@ -1,48 +0,0 @@
-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

@@ -1,101 +0,0 @@
-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

@@ -1,37 +0,0 @@
-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

@@ -1,79 +0,0 @@
-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

@@ -1,203 +0,0 @@
-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|
-          definition_override = node_definition_override(node, child_node)
-          includes_for_child(child_node, includes, definition_override)
-        end
-      end
-
-      private
-
-      def includes_for_child(node, includes, definition_override)
-        return includes_for_connection(node, includes, definition_override) if node.definition.connection?
-
-        builder = build_includes(node, definition_override)
-        return unless builder.present?
-        includes.merge_includes(builder.includes) unless builder.includes.empty?
-
-        return unless builder.includes?
-
-        # 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|
-          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 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|
-          # 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|
-                  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(connection_node, edge_child_node)
-                includes_for_child(edge_child_node, edges_includes, definition_override)
-              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|
-              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`
-          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, 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
-          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
-
-      def build_includes(node, definition_override)
-        definition = definition_override || node.definition
-        includes_meta = 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, definition_override)
-        definition = definition_override || node.definition
-        includes_meta = 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
-
-      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
-end