graphql 1.11.3 → 1.12.0

data/lib/graphql/types/relay/base_edge.rb

@@ -21,40 +21,8 @@ module GraphQL
       #   end
       #
       # @see {Relay::BaseConnection} for connection types
-      class BaseEdge < Types::Relay::BaseObject
-        description "An edge in a connection."
-
-        class << self
-          # Get or set the Object type that this edge wraps.
-          #
-          # @param node_type [Class] A `Schema::Object` subclass
-          # @param null [Boolean]
-          def node_type(node_type = nil, null: true)
-            if node_type
-              @node_type = node_type
-              # Add a default `node` field
-              field :node, node_type, null: null, description: "The item at the end of the edge."
-            end
-            @node_type
-          end
-
-          def authorized?(obj, ctx)
-            true
-          end
-
-          def accessible?(ctx)
-            node_type.accessible?(ctx)
-          end
-
-          def visible?(ctx)
-            node_type.visible?(ctx)
-          end
-        end
-
-
-        field :cursor, String,
-          null: false,
-          description: "A cursor for use in pagination."
+      class BaseEdge < GraphQL::Schema::Object
+        include Types::Relay::EdgeBehaviors
       end
     end
   end

data/lib/graphql/types/relay/connection_behaviors.rb

@@ -0,0 +1,123 @@
+# frozen_string_literal: true
+
+module GraphQL
+  module Types
+    module Relay
+      module ConnectionBehaviors
+        extend Forwardable
+        def_delegators :@object, :cursor_from_node, :parent
+
+        def self.included(child_class)
+          child_class.extend(ClassMethods)
+          child_class.extend(Relay::DefaultRelay)
+          child_class.default_relay(true)
+          child_class.node_nullable(true)
+          add_page_info_field(child_class)
+        end
+
+        module ClassMethods
+          # @return [Class]
+          attr_reader :node_type
+
+          # @return [Class]
+          attr_reader :edge_class
+
+          # Configure this connection to return `edges` and `nodes` based on `edge_type_class`.
+          #
+          # This method will use the inputs to create:
+          # - `edges` field
+          # - `nodes` field
+          # - description
+          #
+          # It's called when you subclass this base connection, trying to use the
+          # class name to set defaults. You can call it again in the class definition
+          # to override the default (or provide a value, if the default lookup failed).
+          def edge_type(edge_type_class, edge_class: GraphQL::Relay::Edge, node_type: edge_type_class.node_type, nodes_field: true, node_nullable: self.node_nullable)
+            # Set this connection's graphql name
+            node_type_name = node_type.graphql_name
+
+            @node_type = node_type
+            @edge_type = edge_type_class
+            @edge_class = edge_class
+
+            field :edges, [edge_type_class, null: true],
+              null: true,
+              description: "A list of edges.",
+              legacy_edge_class: edge_class, # This is used by the old runtime only, for EdgesInstrumentation
+              connection: false
+
+            define_nodes_field(node_nullable) if nodes_field
+
+            description("The connection type for #{node_type_name}.")
+          end
+
+          # Filter this list according to the way its node type would scope them
+          def scope_items(items, context)
+            node_type.scope_items(items, context)
+          end
+
+          # Add the shortcut `nodes` field to this connection and its subclasses
+          def nodes_field(node_nullable: self.node_nullable)
+            define_nodes_field(node_nullable)
+          end
+
+          def authorized?(obj, ctx)
+            true # Let nodes be filtered out
+          end
+
+          def accessible?(ctx)
+            node_type.accessible?(ctx)
+          end
+
+          def visible?(ctx)
+            node_type.visible?(ctx)
+          end
+
+          # Set the default `node_nullable` for this class and its child classes. (Defaults to `true`.)
+          # Use `node_nullable(false)` in your base class to make non-null `node` and `nodes` fields.
+          def node_nullable(new_value = nil)
+            if new_value.nil?
+              @node_nullable || superclass.node_nullable
+            else
+              @node_nullable ||= new_value
+            end
+          end
+
+          private
+
+          def define_nodes_field(nullable)
+            field :nodes, [@node_type, null: nullable],
+              null: nullable,
+              description: "A list of nodes.",
+              connection: false
+          end
+        end
+
+        class << self
+          def add_page_info_field(obj_type)
+            obj_type.field :page_info, GraphQL::Types::Relay::PageInfo, null: false, description: "Information to aid in pagination."
+          end
+        end
+
+        # By default this calls through to the ConnectionWrapper's edge nodes method,
+        # but sometimes you need to override it to support the `nodes` field
+        def nodes
+          @object.edge_nodes
+        end
+
+        def edges
+          if @object.is_a?(GraphQL::Pagination::Connection)
+            @object.edges
+          elsif context.interpreter?
+            context.schema.after_lazy(object.edge_nodes) do |nodes|
+              nodes.map { |n| self.class.edge_class.new(n, object) }
+            end
+          else
+            # This is done by edges_instrumentation
+            @object.edge_nodes
+          end
+        end
+      end
+    end
+  end
+end

data/lib/graphql/types/relay/default_relay.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module GraphQL
+  module Types
+    module Relay
+      module DefaultRelay
+        def self.extended(child_class)
+          child_class.default_relay(true)
+        end
+
+        def default_relay(new_value)
+          @default_relay = new_value
+        end
+
+        def default_relay?
+          !!@default_relay
+        end
+
+        def to_graphql
+          type_defn = super
+          type_defn.default_relay = default_relay?
+          type_defn
+        end
+      end
+    end
+  end
+end

data/lib/graphql/types/relay/edge_behaviors.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module GraphQL
+  module Types
+    module Relay
+      module EdgeBehaviors
+        def self.included(child_class)
+          child_class.description("An edge in a connection.")
+          child_class.field(:cursor, String, null: false, description: "A cursor for use in pagination.")
+          child_class.extend(ClassMethods)
+        end
+
+        module ClassMethods
+          # Get or set the Object type that this edge wraps.
+          #
+          # @param node_type [Class] A `Schema::Object` subclass
+          # @param null [Boolean]
+          def node_type(node_type = nil, null: true)
+            if node_type
+              @node_type = node_type
+              # Add a default `node` field
+              field :node, node_type, null: null, description: "The item at the end of the edge.", connection: false
+            end
+            @node_type
+          end
+
+          def authorized?(obj, ctx)
+            true
+          end
+
+          def accessible?(ctx)
+            node_type.accessible?(ctx)
+          end
+
+          def visible?(ctx)
+            node_type.visible?(ctx)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/graphql/types/relay/has_node_field.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module GraphQL
+  module Types
+    module Relay
+      module HasNodeField
+        def self.included(child_class)
+          child_class.field(**field_options, &field_block)
+        end
+
+        class << self
+          def field_options
+            {
+              name: "node",
+              owner: nil,
+              type: GraphQL::Types::Relay::Node,
+              null: true,
+              description: "Fetches an object given its ID.",
+              relay_node_field: true,
+            }
+          end
+
+          def field_block
+            Proc.new {
+              argument :id, "ID!", required: true,
+                description: "ID of the object."
+
+              def resolve(obj, args, ctx)
+                ctx.schema.object_from_id(args[:id], ctx)
+              end
+
+              def resolve_field(obj, args, ctx)
+                resolve(obj, args, ctx)
+              end
+            }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/graphql/types/relay/has_nodes_field.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module GraphQL
+  module Types
+    module Relay
+      module HasNodesField
+        def self.included(child_class)
+          child_class.field(**field_options, &field_block)
+        end
+
+        class << self
+          def field_options
+            {
+              name: "nodes",
+              owner: nil,
+              type: [GraphQL::Types::Relay::Node, null: true],
+              null: false,
+              description: "Fetches a list of objects given a list of IDs.",
+              relay_nodes_field: true,
+            }
+          end
+
+          def field_block
+            Proc.new {
+              argument :ids, "[ID!]!", required: true,
+                description: "IDs of the objects."
+
+              def resolve(obj, args, ctx)
+                args[:ids].map { |id| ctx.schema.object_from_id(id, ctx) }
+              end
+
+              def resolve_field(obj, args, ctx)
+                resolve(obj, args, ctx)
+              end
+            }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/graphql/types/relay/node.rb

@@ -7,10 +7,8 @@ module GraphQL
       # or you can take it as inspiration for your own implementation
       # of the `Node` interface.
       module Node
-        include Types::Relay::BaseInterface
-        default_relay(true)
-        description "An object with an ID."
-        field(:id, ID, null: false, description: "ID of the object.")
+        include GraphQL::Schema::Interface
+        include Types::Relay::NodeBehaviors
       end
     end
   end

data/lib/graphql/types/relay/node_behaviors.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module GraphQL
+  module Types
+    module Relay
+      module NodeBehaviors
+        def self.included(child_module)
+          child_module.extend(DefaultRelay)
+          child_module.description("An object with an ID.")
+          child_module.field(:id, ID, null: false, description: "ID of the object.")
+        end
+      end
+    end
+  end
+end

data/lib/graphql/types/relay/node_field.rb

@@ -19,25 +19,7 @@ module GraphQL
       #     context.schema.object_from_id(id, context)
       #   end
       #
-      NodeField = GraphQL::Schema::Field.new(
-        name: "node",
-        owner: nil,
-        type: GraphQL::Types::Relay::Node,
-        null: true,
-        description: "Fetches an object given its ID.",
-        relay_node_field: true,
-      ) do
-        argument :id, "ID!", required: true,
-          description: "ID of the object."
-
-        def resolve(obj, args, ctx)
-          ctx.schema.object_from_id(args[:id], ctx)
-        end
-
-        def resolve_field(obj, args, ctx)
-          resolve(obj, args, ctx)
-        end
-      end
+      NodeField = GraphQL::Schema::Field.new(**HasNodeField.field_options, &HasNodeField.field_block)
     end
   end
 end

data/lib/graphql/types/relay/nodes_field.rb

@@ -21,25 +21,7 @@ module GraphQL
       #     end
       #   end
       #
-      NodesField = GraphQL::Schema::Field.new(
-        name: "nodes",
-        owner: nil,
-        type: [GraphQL::Types::Relay::Node, null: true],
-        null: false,
-        description: "Fetches a list of objects given a list of IDs.",
-        relay_nodes_field: true,
-      ) do
-        argument :ids, "[ID!]!", required: true,
-          description: "IDs of the objects."
-
-        def resolve(obj, args, ctx)
-          args[:ids].map { |id| ctx.schema.object_from_id(id, ctx) }
-        end
-
-        def resolve_field(obj, args, ctx)
-          resolve(obj, args, ctx)
-        end
-      end
+      NodesField = GraphQL::Schema::Field.new(**HasNodesField.field_options, &HasNodesField.field_block)
     end
   end
 end

data/lib/graphql/types/relay/page_info.rb

@@ -3,20 +3,8 @@ module GraphQL
   module Types
     module Relay
       # The return type of a connection's `pageInfo` field
-      class PageInfo < Types::Relay::BaseObject
-        default_relay true
-        description "Information about pagination in a connection."
-        field :has_next_page, Boolean, null: false,
-          description: "When paginating forwards, are there more items?"
-
-        field :has_previous_page, Boolean, null: false,
-          description: "When paginating backwards, are there more items?"
-
-        field :start_cursor, String, null: true,
-          description: "When paginating backwards, the cursor to continue."
-
-        field :end_cursor, String, null: true,
-          description: "When paginating forwards, the cursor to continue."
+      class PageInfo < GraphQL::Schema::Object
+        include PageInfoBehaviors
       end
     end
   end

data/lib/graphql/types/relay/page_info_behaviors.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+module GraphQL
+  module Types
+    module Relay
+      module PageInfoBehaviors
+        def self.included(child_class)
+          child_class.extend GraphQL::Types::Relay::DefaultRelay
+
+          child_class.description "Information about pagination in a connection."
+          child_class.field :has_next_page, Boolean, null: false,
+            description: "When paginating forwards, are there more items?"
+
+          child_class.field :has_previous_page, Boolean, null: false,
+            description: "When paginating backwards, are there more items?"
+
+          child_class.field :start_cursor, String, null: true,
+            description: "When paginating backwards, the cursor to continue."
+
+          child_class.field :end_cursor, String, null: true,
+            description: "When paginating forwards, the cursor to continue."
+        end
+      end
+    end
+  end
+end