graphql 1.9.5 → 1.13.19

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

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module GraphQL
+  module Types
+    module Relay
+      # Include this module to your root Query type to get a Relay-compliant `node(id: ID!): Node` field that uses the schema's `object_from_id` hook.
+      module HasNodeField
+        def self.included(child_class)
+          child_class.field(**field_options, &field_block)
+        end
+
+        class << self
+          def field_options
+            {
+              name: "node",
+              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!",
+                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
+      # Include this module to your root Query type to get a Relay-style `nodes(id: ID!): [Node]` field that uses the schema's `object_from_id` hook.
+      module HasNodesField
+        def self.included(child_class)
+          child_class.field(**field_options, &field_block)
+        end
+
+        class << self
+          def field_options
+            {
+              name: "nodes",
+              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!]!",
+                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

@@ -2,11 +2,10 @@
 module GraphQL
   module Types
     module Relay
-      # This can be used for implementing `Query.node(id: ...)`,
-      # or use it for inspiration for your own field definition.
+      # Don't use this field directly, instead, use one of these approaches:
       #
       # @example Adding this field directly
-      #   add_field(GraphQL::Types::Relay::NodeField)
+      #   include GraphQL::Types::Relay::HasNodeField
       #
       # @example Implementing a similar field in your own Query root
       #
@@ -16,28 +15,10 @@ module GraphQL
       #     end
       #
       #   def node(id:)
-      #     context.schema.object_from_id(context, id)
+      #     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
+      DeprecatedNodeField = GraphQL::Schema::Field.new(owner: nil, **HasNodeField.field_options, &HasNodeField.field_block)
     end
   end
 end

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

@@ -2,11 +2,10 @@
 module GraphQL
   module Types
     module Relay
-      # This can be used for implementing `Query.nodes(ids: ...)`,
-      # or use it for inspiration for your own field definition.
+      # Don't use this directly, instead, use one of these:
       #
       # @example Adding this field directly
-      #   add_field(GraphQL::Types::Relay::NodesField)
+      #   include GraphQL::Types::Relay::HasNodesField
       #
       # @example Implementing a similar field in your own Query root
       #
@@ -21,25 +20,24 @@ 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 self.const_missing(const_name)
+        if const_name == :NodesField
+          message = "NodesField is deprecated, use `include GraphQL::Types::Relay::HasNodesField` instead."
+          message += "\n(referenced from #{caller(1, 1).first})"
+          GraphQL::Deprecation.warn(message)
 
-        def resolve(obj, args, ctx)
-          args[:ids].map { |id| ctx.schema.object_from_id(id, ctx) }
-        end
+          DeprecatedNodesField
+        elsif const_name == :NodeField
+          message = "NodeField is deprecated, use `include GraphQL::Types::Relay::HasNodeField` instead."
+          message += "\n(referenced from #{caller(1, 1).first})"
+          GraphQL::Deprecation.warn(message)
 
-        def resolve_field(obj, args, ctx)
-          resolve(obj, args, ctx)
+          DeprecatedNodeField
+        else
+          super
         end
       end
+      DeprecatedNodesField = GraphQL::Schema::Field.new(owner: nil, **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

data/lib/graphql/types/relay.rb

@@ -1,7 +1,15 @@
 # frozen_string_literal: true
-require "graphql/types/relay/base_field"
-require "graphql/types/relay/base_object"
-require "graphql/types/relay/base_interface"
+
+# behavior modules:
+require "graphql/types/relay/default_relay"
+require "graphql/types/relay/connection_behaviors"
+require "graphql/types/relay/edge_behaviors"
+require "graphql/types/relay/node_behaviors"
+require "graphql/types/relay/page_info_behaviors"
+require "graphql/types/relay/has_node_field"
+require "graphql/types/relay/has_nodes_field"
+
+# concrete classes based on the gem defaults:
 require "graphql/types/relay/page_info"
 require "graphql/types/relay/base_connection"
 require "graphql/types/relay/base_edge"

data/lib/graphql/types/string.rb

@@ -7,9 +7,15 @@ module GraphQL
 
       def self.coerce_result(value, ctx)
         str = value.to_s
-        str.encoding == Encoding::UTF_8 ? str : str.encode(Encoding::UTF_8)
+        if str.ascii_only? || str.encoding == Encoding::UTF_8
+          str
+        elsif str.frozen?
+          str.encode(Encoding::UTF_8)
+        else
+          str.encode!(Encoding::UTF_8)
+        end
       rescue EncodingError
-        err = GraphQL::StringEncodingError.new(str)
+        err = GraphQL::StringEncodingError.new(str, context: ctx)
         ctx.schema.type_error(err, ctx)
       end
 

data/lib/graphql/types.rb

@@ -4,6 +4,7 @@ require "graphql/types/big_int"
 require "graphql/types/float"
 require "graphql/types/id"
 require "graphql/types/int"
+require "graphql/types/iso_8601_date"
 require "graphql/types/iso_8601_date_time"
 require "graphql/types/json"
 require "graphql/types/string"

data/lib/graphql/unauthorized_error.rb

@@ -12,7 +12,7 @@ module GraphQL
     attr_reader :type
 
     # @return [GraphQL::Query::Context] the context for the current query
-    attr_reader :context
+    attr_accessor :context
 
     def initialize(message = nil, object: nil, type: nil, context: nil)
       if message.nil? && object.nil? && type.nil?
@@ -22,7 +22,7 @@ module GraphQL
       @object = object
       @type = type
       @context = context
-      message ||= "An instance of #{object.class} failed #{type.name}'s authorization check"
+      message ||= "An instance of #{object.class} failed #{type.graphql_name}'s authorization check"
       super(message)
     end
   end

data/lib/graphql/union_type.rb

@@ -1,45 +1,37 @@
 # frozen_string_literal: true
 module GraphQL
-  # A Union is is a collection of object types which may appear in the same place.
-  #
-  # The members of a union are declared with `possible_types`.
-  #
-  # @example A union of object types
-  #   MediaUnion = GraphQL::UnionType.define do
-  #     name "Media"
-  #     description "Media objects which you can enjoy"
-  #     possible_types [AudioType, ImageType, VideoType]
-  #   end
-  #
-  # A union itself has no fields; only its members have fields.
-  # So, when you query, you must use fragment spreads to access fields.
-  #
-  # @example Querying for fields on union members
-  #  {
-  #    searchMedia(name: "Jens Lekman") {
-  #      ... on Audio { name, duration }
-  #      ... on Image { name, height, width }
-  #      ... on Video { name, length, quality }
-  #    }
-  #  }
-  #
+  # @api deprecated
   class UnionType < GraphQL::BaseType
-    accepts_definitions :possible_types, :resolve_type
-    ensure_defined :possible_types, :resolve_type, :resolve_type_proc
+    extend Define::InstanceDefinable::DeprecatedDefine
+
+    # Rubocop was unhappy about the syntax when this was a proc literal
+    class AcceptPossibleTypesDefinition
+      def self.call(target, possible_types, options = {})
+        target.add_possible_types(possible_types, **options)
+      end
+    end
+
+    deprecated_accepts_definitions :resolve_type, :type_membership_class,
+      possible_types: AcceptPossibleTypesDefinition
+    ensure_defined :possible_types, :resolve_type, :resolve_type_proc, :type_membership_class
 
     attr_accessor :resolve_type_proc
+    attr_reader :type_memberships
+    attr_accessor :type_membership_class
 
     def initialize
       super
-      @dirty_possible_types = []
-      @clean_possible_types = nil
+      @type_membership_class = GraphQL::Schema::TypeMembership
+      @type_memberships = []
+      @cached_possible_types = nil
       @resolve_type_proc = nil
     end
 
     def initialize_copy(other)
       super
-      @clean_possible_types = nil
-      @dirty_possible_types = other.dirty_possible_types.dup
+      @type_membership_class = other.type_membership_class
+      @type_memberships = other.type_memberships.dup
+      @cached_possible_types = nil
     end
 
     def kind
@@ -47,33 +39,44 @@ module GraphQL
     end
 
     # @return [Boolean] True if `child_type_defn` is a member of this {UnionType}
-    def include?(child_type_defn)
-      possible_types.include?(child_type_defn)
-    end
-
-    def possible_types=(new_possible_types)
-      @clean_possible_types = nil
-      @dirty_possible_types = new_possible_types
+    def include?(child_type_defn, ctx = GraphQL::Query::NullContext)
+      possible_types(ctx).include?(child_type_defn)
     end
 
     # @return [Array<GraphQL::ObjectType>] Types which may be found in this union
-    def possible_types
-      @clean_possible_types ||= begin
-        if @dirty_possible_types.respond_to?(:map)
-          @dirty_possible_types.map { |type| GraphQL::BaseType.resolve_related_type(type) }
-        else
-          @dirty_possible_types
-        end
+    def possible_types(ctx = GraphQL::Query::NullContext)
+      if ctx == GraphQL::Query::NullContext
+        # Only cache the default case; if we cached for every `ctx`, it would be a memory leak
+        # (The warden should cache calls to this method, so it's called only once per query,
+        # unless user code calls it directly.)
+        @cached_possible_types ||= possible_types_for_context(ctx)
+      else
+        possible_types_for_context(ctx)
       end
     end
 
+    def possible_types=(types)
+      # This is a re-assignment, so clear the previous values
+      @type_memberships = []
+      @cached_possible_types = nil
+      add_possible_types(types, **{})
+    end
+
+    def add_possible_types(types, **options)
+      @type_memberships ||= []
+      Array(types).each { |t|
+        @type_memberships << self.type_membership_class.new(self, t, **options)
+      }
+      nil
+    end
+
     # Get a possible type of this {UnionType} by type name
     # @param type_name [String]
     # @param ctx [GraphQL::Query::Context] The context for the current query
     # @return [GraphQL::ObjectType, nil] The type named `type_name` if it exists and is a member of this {UnionType}, (else `nil`)
     def get_possible_type(type_name, ctx)
       type = ctx.query.get_type(type_name)
-      type if type && ctx.query.schema.possible_types(self).include?(type)
+      type if type && ctx.query.warden.possible_types(self).include?(type)
     end
 
     # Check if a type is a possible type of this {UnionType}
@@ -93,8 +96,20 @@ module GraphQL
       @resolve_type_proc = new_resolve_type_proc
     end
 
-    protected
+    def type_memberships=(type_memberships)
+      @type_memberships = type_memberships
+    end
+
+    private
 
-    attr_reader :dirty_possible_types
+    def possible_types_for_context(ctx)
+      visible_types = []
+      @type_memberships.each do |type_membership|
+        if type_membership.visible?(ctx)
+          visible_types << BaseType.resolve_related_type(type_membership.object_type)
+        end
+      end
+      visible_types
+    end
   end
 end

data/lib/graphql/unresolved_type_error.rb

@@ -24,8 +24,8 @@ module GraphQL
       @parent_type = parent_type
       @resolved_type = resolved_type
       @possible_types = possible_types
-      message = "The value from \"#{field.name}\" on \"#{parent_type}\" could not be resolved to \"#{field.type}\". " \
-        "(Received: `#{resolved_type.inspect}`, Expected: [#{possible_types.map(&:inspect).join(", ")}]) " \
+      message = "The value from \"#{field.graphql_name}\" on \"#{parent_type.graphql_name}\" could not be resolved to \"#{field.type.to_type_signature}\". " \
+        "(Received: `#{resolved_type.inspect}`, Expected: [#{possible_types.map(&:graphql_name).join(", ")}]) " \
         "Make sure you have defined a `resolve_type` proc on your schema and that value `#{value.inspect}` " \
         "gets resolved to a valid type. You may need to add your type to `orphan_types` if it implements an " \
         "interface but isn't a return type of any other field."