graphql 0.16.0 → 2.0.15

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

@@ -0,0 +1,154 @@
+# 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.has_nodes_field(true)
+          child_class.node_nullable(true)
+          child_class.edges_nullable(true)
+          child_class.edge_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).
+          # @param field_options [Hash] Any extra keyword arguments to pass to the `field :edges, ...` and `field :nodes, ...` configurations
+          def edge_type(edge_type_class, edge_class: GraphQL::Pagination::Connection::Edge, node_type: edge_type_class.node_type, nodes_field: self.has_nodes_field, node_nullable: self.node_nullable, edges_nullable: self.edges_nullable, edge_nullable: self.edge_nullable, field_options: nil)
+            # 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
+
+            base_field_options = {
+              name: :edges,
+              type: [edge_type_class, null: edge_nullable],
+              null: edges_nullable,
+              description: "A list of edges.",
+              connection: false,
+            }
+
+            if field_options
+              base_field_options.merge!(field_options)
+            end
+
+            field(**base_field_options)
+
+            define_nodes_field(node_nullable, field_options: field_options) 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, field_options: nil)
+            define_nodes_field(node_nullable, field_options: field_options)
+          end
+
+          def authorized?(obj, ctx)
+            true # Let nodes be filtered out
+          end
+
+          def accessible?(ctx)
+            node_type.accessible?(ctx)
+          end
+
+          def visible?(ctx)
+            # if this is an abstract base class, there may be no `node_type`
+            node_type ? node_type.visible?(ctx) : super
+          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?
+              defined?(@node_nullable) ? @node_nullable : superclass.node_nullable
+            else
+              @node_nullable = new_value
+            end
+          end
+
+          # Set the default `edges_nullable` for this class and its child classes. (Defaults to `true`.)
+          # Use `edges_nullable(false)` in your base class to make non-null `edges` fields.
+          def edges_nullable(new_value = nil)
+            if new_value.nil?
+              defined?(@edges_nullable) ? @edges_nullable : superclass.edges_nullable
+            else
+              @edges_nullable = new_value
+            end
+          end
+
+          # Set the default `edge_nullable` for this class and its child classes. (Defaults to `true`.)
+          # Use `edge_nullable(false)` in your base class to make non-null `edge` fields.
+          def edge_nullable(new_value = nil)
+            if new_value.nil?
+              defined?(@edge_nullable) ? @edge_nullable : superclass.edge_nullable
+            else
+              @edge_nullable = new_value
+            end
+          end
+
+          # Set the default `nodes_field` for this class and its child classes. (Defaults to `true`.)
+          # Use `nodes_field(false)` in your base class to prevent adding of a nodes field.
+          def has_nodes_field(new_value = nil)
+            if new_value.nil?
+              defined?(@nodes_field) ? @nodes_field : superclass.has_nodes_field
+            else
+              @nodes_field = new_value
+            end
+          end
+
+          private
+
+          def define_nodes_field(nullable, field_options: nil)
+            base_field_options = {
+              name: :nodes,
+              type: [@node_type, null: nullable],
+              null: nullable,
+              description: "A list of nodes.",
+              connection: false,
+            }
+            if field_options
+              base_field_options.merge!(field_options)
+            end
+            field(**base_field_options)
+          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
+      end
+    end
+  end
+end

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

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

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

@@ -0,0 +1,64 @@
+# 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)
+          child_class.node_nullable(true)
+        end
+
+        module ClassMethods
+          # Get or set the Object type that this edge wraps.
+          #
+          # @param node_type [Class] A `Schema::Object` subclass
+          # @param null [Boolean]
+          # @param field_options [Hash] Any extra arguments to pass to the `field :node` configuration
+          def node_type(node_type = nil, null: self.node_nullable, field_options: nil)
+            if node_type
+              @node_type = node_type
+              # Add a default `node` field
+              base_field_options = {
+                name: :node,
+                type: node_type,
+                null: null,
+                description: "The item at the end of the edge.",
+                connection: false,
+              }
+              if field_options
+                base_field_options.merge!(field_options)
+              end
+              field(**base_field_options)
+            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
+
+          # 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` field.
+          def node_nullable(new_value = nil)
+            if new_value.nil?
+              defined?(@node_nullable) ? @node_nullable : superclass.node_nullable
+            else
+              @node_nullable = new_value
+            end
+          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
+      # 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

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module GraphQL
+  module Types
+    module Relay
+      # This can be used for Relay's `Node` interface,
+      # or you can take it as inspiration for your own implementation
+      # of the `Node` interface.
+      module Node
+        include GraphQL::Schema::Interface
+        include Types::Relay::NodeBehaviors
+      end
+    end
+  end
+end

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

@@ -0,0 +1,19 @@
+# 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.", resolver_method: :default_global_id)
+        end
+
+        def default_global_id
+          context.schema.id_from_object(object, self.class, context)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+module GraphQL
+  module Types
+    module Relay
+      # The return type of a connection's `pageInfo` field
+      class PageInfo < GraphQL::Schema::Object
+        include PageInfoBehaviors
+      end
+    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

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+# 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"
+require "graphql/types/relay/node"
+
+module GraphQL
+  module Types
+    # This module contains some types and fields that could support Relay conventions in GraphQL.
+    #
+    # You can use these classes out of the box if you want, but if you want to use your _own_
+    # GraphQL extensions along with the features in this code, you could also
+    # open up the source files and copy the relevant methods and configuration into
+    # your own classes.
+    #
+    # For example, the provided object types extend {Types::Relay::BaseObject},
+    # but you might want to:
+    #
+    # 1. Migrate the extensions from {Types::Relay::BaseObject} into _your app's_ base object
+    # 2. Copy {Relay::BaseConnection}, {Relay::BaseEdge}, etc into _your app_, and
+    #   change them to extend _your_ base object.
+    #
+    # Similarly, `BaseField`'s extensions could be migrated to your app
+    # and `Node` could be implemented to mix in your base interface module.
+    module Relay
+    end
+  end
+end

data/lib/graphql/types/string.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module GraphQL
+  module Types
+    class String < GraphQL::Schema::Scalar
+      description "Represents textual data as UTF-8 character sequences. This type is most often used by GraphQL to represent free-form human-readable text."
+
+      def self.coerce_result(value, ctx)
+        str = value.to_s
+        if 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, context: ctx)
+        ctx.schema.type_error(err, ctx)
+      end
+
+      def self.coerce_input(value, _ctx)
+        value.is_a?(::String) ? value : nil
+      end
+
+      default_scalar true
+    end
+  end
+end

data/lib/graphql/types.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+require "graphql/types/boolean"
+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"
+require "graphql/types/relay"

data/lib/graphql/unauthorized_error.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+module GraphQL
+  # When an `authorized?` hook returns false, this error is used to communicate the failure.
+  # It's passed to {Schema.unauthorized_object}.
+  #
+  # Alternatively, custom code in `authorized?` may raise this error. It will be routed the same way.
+  class UnauthorizedError < GraphQL::Error
+    # @return [Object] the application object that failed the authorization check
+    attr_reader :object
+
+    # @return [Class] the GraphQL object type whose `.authorized?` method was called (and returned false)
+    attr_reader :type
+
+    # @return [GraphQL::Query::Context] the context for the current query
+    attr_accessor :context
+
+    def initialize(message = nil, object: nil, type: nil, context: nil)
+      if message.nil? && object.nil? && type.nil?
+        raise ArgumentError, "#{self.class.name} requires either a message or keywords"
+      end
+
+      @object = object
+      @type = type
+      @context = context
+      message ||= "An instance of #{object.class} failed #{type.graphql_name}'s authorization check"
+      super(message)
+    end
+  end
+end

data/lib/graphql/unauthorized_field_error.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+module GraphQL
+  class UnauthorizedFieldError < GraphQL::UnauthorizedError
+    # @return [Field] the field that failed the authorization check
+    attr_accessor :field
+
+    def initialize(message = nil, object: nil, type: nil, context: nil, field: nil)
+      if message.nil? && [field, type].any?(&:nil?)
+        raise ArgumentError, "#{self.class.name} requires either a message or keywords"
+      end
+
+      @field = field
+      message ||= begin
+        if object
+          "An instance of #{object.class} failed #{type.name}'s authorization check on field #{field.name}"
+        else
+          "Failed #{type.name}'s authorization check on field #{field.name}"
+        end
+      end
+      super(message, object: object, type: type, context: context)
+    end
+  end
+end

data/lib/graphql/unresolved_type_error.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+module GraphQL
+  # Error raised when the value provided for a field
+  # can't be resolved to one of the possible types for the field.
+  class UnresolvedTypeError < GraphQL::RuntimeTypeError
+    # @return [Object] The runtime value which couldn't be successfully resolved with `resolve_type`
+    attr_reader :value
+
+    # @return [GraphQL::Field] The field whose value couldn't be resolved (`field.type` is type which couldn't be resolved)
+    attr_reader :field
+
+    # @return [GraphQL::BaseType] The owner of `field`
+    attr_reader :parent_type
+
+    # @return [Object] The return of {Schema#resolve_type} for `value`
+    attr_reader :resolved_type
+
+    # @return [Array<GraphQL::BaseType>] The allowed options for resolving `value` to `field.type`
+    attr_reader :possible_types
+
+    def initialize(value, field, parent_type, resolved_type, possible_types)
+      @value = value
+      @field = field
+      @parent_type = parent_type
+      @resolved_type = resolved_type
+      @possible_types = possible_types
+      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."
+      super(message)
+    end
+  end
+end

data/lib/graphql/version.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 module GraphQL
-  VERSION = "0.16.0"
+  VERSION = "2.0.15"
 end