graphql 0.16.0 → 2.0.15

data/lib/graphql/introspection/enum_value_type.rb

@@ -1,10 +1,23 @@
-GraphQL::Introspection::EnumValueType = GraphQL::ObjectType.define do
-  name "__EnumValue"
-  description "A possible value for an Enum"
-  field :name, !types.String
-  field :description, types.String
-  field :deprecationReason, types.String, property: :deprecation_reason
-  field :isDeprecated, !types.Boolean do
-    resolve -> (obj, a, c) { !!obj.deprecation_reason }
+# frozen_string_literal: true
+module GraphQL
+  module Introspection
+    class EnumValueType < Introspection::BaseObject
+      graphql_name "__EnumValue"
+      description "One possible value for a given Enum. Enum values are unique values, not a "\
+                  "placeholder for a string or numeric value. However an Enum value is returned in "\
+                  "a JSON response as a string."
+      field :name, String, null: false
+      field :description, String
+      field :is_deprecated, Boolean, null: false
+      field :deprecation_reason, String
+
+      def name
+        object.graphql_name
+      end
+
+      def is_deprecated
+        !!@object.deprecation_reason
+      end
+    end
   end
 end

data/lib/graphql/introspection/field_type.rb

@@ -1,12 +1,28 @@
-GraphQL::Introspection::FieldType = GraphQL::ObjectType.define do
-  name "__Field"
-  description "Field on a GraphQL type"
-  field :name, !types.String, "The name for accessing this field"
-  field :description, types.String, "The description of this field"
-  field :type, !GraphQL::Introspection::TypeType, "The return type of this field"
-  field :isDeprecated, !types.Boolean, "Is this field deprecated?" do
-    resolve -> (obj, a, c) { !!obj.deprecation_reason }
+# frozen_string_literal: true
+module GraphQL
+  module Introspection
+    class FieldType < Introspection::BaseObject
+      graphql_name "__Field"
+      description "Object and Interface types are described by a list of Fields, each of which has "\
+                  "a name, potentially a list of arguments, and a return type."
+      field :name, String, null: false
+      field :description, String
+      field :args, [GraphQL::Schema::LateBoundType.new("__InputValue")], null: false do
+        argument :include_deprecated, Boolean, required: false, default_value: false
+      end
+      field :type, GraphQL::Schema::LateBoundType.new("__Type"), null: false
+      field :is_deprecated, Boolean, null: false
+      field :deprecation_reason, String
+
+      def is_deprecated
+        !!@object.deprecation_reason
+      end
+
+      def args(include_deprecated:)
+        args = @context.warden.arguments(@object)
+        args = args.reject(&:deprecation_reason) unless include_deprecated
+        args
+      end
+    end
   end
-  field :args, field: GraphQL::Introspection::ArgumentsField
-  field :deprecationReason, types.String,  "Why this field was deprecated", property: :deprecation_reason
 end

data/lib/graphql/introspection/input_value_type.rb

@@ -1,17 +1,67 @@
-GraphQL::Introspection::InputValueType = GraphQL::ObjectType.define do
-  name "__InputValue"
-  description "An input for a field or InputObject"
-  field :name, !types.String, "The key for this value"
-  field :description, types.String, "What this value is used for"
-  field :type, -> { !GraphQL::Introspection::TypeType }, "The expected type for this value"
-  field :defaultValue, types.String, "The value applied if no other value is provided" do
-    resolve -> (obj, args, ctx) {
-      value = obj.default_value
-      if value.is_a?(String)
-        "\"#{value}\""
-      else
-        value
+# frozen_string_literal: true
+module GraphQL
+  module Introspection
+    class InputValueType < Introspection::BaseObject
+      graphql_name "__InputValue"
+      description "Arguments provided to Fields or Directives and the input fields of an "\
+                  "InputObject are represented as Input Values which describe their type and "\
+                  "optionally a default value."
+      field :name, String, null: false
+      field :description, String
+      field :type, GraphQL::Schema::LateBoundType.new("__Type"), null: false
+      field :default_value, String, "A GraphQL-formatted string representing the default value for this input value."
+      field :is_deprecated, Boolean, null: false
+      field :deprecation_reason, String
+
+      def is_deprecated
+        !!@object.deprecation_reason
       end
-    }
+
+      def default_value
+        if @object.default_value?
+          value = @object.default_value
+          if value.nil?
+            'null'
+          else
+            if (@object.type.kind.list? || (@object.type.kind.non_null? && @object.type.of_type.kind.list?)) && !value.respond_to?(:map)
+              # This is a bit odd -- we expect the default value to be an application-style value, so we use coerce result below.
+              # But coerce_result doesn't wrap single-item lists, which are valid inputs to list types.
+              # So, apply that wrapper here if needed.
+              value = [value]
+            end
+            coerced_default_value = @object.type.coerce_result(value, @context)
+            serialize_default_value(coerced_default_value, @object.type)
+          end
+        else
+          nil
+        end
+      end
+
+
+      private
+
+      # Recursively serialize, taking care not to add quotes to enum values
+      def serialize_default_value(value, type)
+        if value.nil?
+          'null'
+        elsif type.kind.list?
+          inner_type = type.of_type
+          "[" + value.map { |v| serialize_default_value(v, inner_type) }.join(", ") + "]"
+        elsif type.kind.non_null?
+          serialize_default_value(value, type.of_type)
+        elsif type.kind.enum?
+          value
+        elsif type.kind.input_object?
+          "{" +
+            value.map do |k, v|
+              arg_defn = type.get_argument(k, context)
+              "#{k}: #{serialize_default_value(v, arg_defn.type)}"
+            end.join(", ") +
+            "}"
+        else
+          GraphQL::Language.serialize(value)
+        end
+      end
+    end
   end
 end

data/lib/graphql/introspection/introspection_query.rb

@@ -1,76 +1,7 @@
-# The introspection query to end all introspection queries, copied from
-# https://github.com/graphql/graphql-js/blob/master/src/utilities/introspectionQuery.js
-GraphQL::Introspection::INTROSPECTION_QUERY = "
-query IntrospectionQuery {
-  __schema {
-    queryType { name }
-    mutationType { name }
-    subscriptionType { name }
-    types {
-      ...FullType
-    }
-    directives {
-      name
-      description
-      locations
-      args {
-        ...InputValue
-      }
-    }
-  }
-}
-fragment FullType on __Type {
-  kind
-  name
-  description
-  fields(includeDeprecated: true) {
-    name
-    description
-    args {
-      ...InputValue
-    }
-    type {
-      ...TypeRef
-    }
-    isDeprecated
-    deprecationReason
-  }
-  inputFields {
-    ...InputValue
-  }
-  interfaces {
-    ...TypeRef
-  }
-  enumValues(includeDeprecated: true) {
-    name
-    description
-    isDeprecated
-    deprecationReason
-  }
-  possibleTypes {
-    ...TypeRef
-  }
-}
-fragment InputValue on __InputValue {
-  name
-  description
-  type { ...TypeRef }
-  defaultValue
-}
-fragment TypeRef on __Type {
-  kind
-  name
-  ofType {
-    kind
-    name
-    ofType {
-      kind
-      name
-      ofType {
-        kind
-        name
-      }
-    }
-  }
-}
-"
+# frozen_string_literal: true
+
+# This query is used by graphql-client so don't add the includeDeprecated
+# argument for inputFields since the server may not support it. Two stage
+# introspection queries will be required to handle this in clients.
+GraphQL::Introspection::INTROSPECTION_QUERY = GraphQL::Introspection.query
+

data/lib/graphql/introspection/schema_type.rb

@@ -1,24 +1,49 @@
-GraphQL::Introspection::SchemaType = GraphQL::ObjectType.define do
-  name "__Schema"
-  description "A GraphQL schema"
+# frozen_string_literal: true
 
-  field :types, !types[!GraphQL::Introspection::TypeType], "Types in this schema" do
-    resolve -> (obj, arg, ctx) { obj.types.values }
-  end
+module GraphQL
+  module Introspection
+    class SchemaType < Introspection::BaseObject
+      graphql_name "__Schema"
+      description "A GraphQL Schema defines the capabilities of a GraphQL server. It exposes all "\
+                  "available types and directives on the server, as well as the entry points for "\
+                  "query, mutation, and subscription operations."
 
-  field :directives, !types[!GraphQL::Introspection::DirectiveType], "Directives in this schema" do
-    resolve -> (obj, arg, ctx) { obj.directives.values }
-  end
+      field :types, [GraphQL::Schema::LateBoundType.new("__Type")], "A list of all types supported by this server.", null: false
+      field :query_type, GraphQL::Schema::LateBoundType.new("__Type"), "The type that query operations will be rooted at.", null: false
+      field :mutation_type, GraphQL::Schema::LateBoundType.new("__Type"), "If this server supports mutation, the type that mutation operations will be rooted at."
+      field :subscription_type, GraphQL::Schema::LateBoundType.new("__Type"), "If this server support subscription, the type that subscription operations will be rooted at."
+      field :directives, [GraphQL::Schema::LateBoundType.new("__Directive")], "A list of all directives supported by this server.", null: false
+      field :description, String, resolver_method: :schema_description
 
-  field :queryType, !GraphQL::Introspection::TypeType, "The query root of this schema" do
-    resolve -> (obj, arg, ctx) { obj.query }
-  end
+      def schema_description
+        context.schema.description
+      end
 
-  field :mutationType, GraphQL::Introspection::TypeType, "The mutation root of this schema" do
-    resolve -> (obj, arg, ctx) { obj.mutation }
-  end
+      def types
+        @context.warden.reachable_types.sort_by(&:graphql_name)
+      end
+
+      def query_type
+        permitted_root_type("query")
+      end
+
+      def mutation_type
+        permitted_root_type("mutation")
+      end
+
+      def subscription_type
+        permitted_root_type("subscription")
+      end
+
+      def directives
+        @context.warden.directives
+      end
+
+      private
 
-  field :subscriptionType, GraphQL::Introspection::TypeType, "The subscription root of this schema" do
-    resolve -> (obj, arg, ctx) { obj.subscription }
+      def permitted_root_type(op_type)
+        @context.warden.root_type_for_operation(op_type)
+      end
+    end
   end
 end

data/lib/graphql/introspection/type_kind_enum.rb

@@ -1,7 +1,13 @@
-GraphQL::Introspection::TypeKindEnum = GraphQL::EnumType.define do
-  name "__TypeKind"
-  description "The kinds of types in this GraphQL system"
-  GraphQL::TypeKinds::KIND_NAMES.each do |kind_name|
-    value(kind_name)
+# frozen_string_literal: true
+module GraphQL
+  module Introspection
+    class TypeKindEnum < GraphQL::Schema::Enum
+      graphql_name "__TypeKind"
+      description "An enum describing what kind of type a given `__Type` is."
+      GraphQL::TypeKinds::TYPE_KINDS.each do |type_kind|
+        value(type_kind.name, type_kind.description)
+      end
+      introspection true
+    end
   end
 end

data/lib/graphql/introspection/type_type.rb

@@ -1,20 +1,108 @@
-GraphQL::Introspection::TypeType = GraphQL::ObjectType.define do
-  name "__Type"
-  description "A type in the GraphQL schema"
+# frozen_string_literal: true
+module GraphQL
+  module Introspection
+    class TypeType < Introspection::BaseObject
+      graphql_name "__Type"
+      description "The fundamental unit of any GraphQL Schema is the type. There are many kinds of types in "\
+                  "GraphQL as represented by the `__TypeKind` enum.\n\n"\
+                  "Depending on the kind of a type, certain fields describe information about that type. "\
+                  "Scalar types provide no information beyond a name and description, while "\
+                  "Enum types provide their values. Object and Interface types provide the fields "\
+                  "they describe. Abstract types, Union and Interface, provide the Object types "\
+                  "possible at runtime. List and NonNull types compose other types."
 
-  field :name, types.String,  "The name of this type"
-  field :description, types.String, "What this type represents"
+      field :kind, GraphQL::Schema::LateBoundType.new("__TypeKind"), null: false
+      field :name, String, method: :graphql_name
+      field :description, String
+      field :fields, [GraphQL::Schema::LateBoundType.new("__Field")] do
+        argument :include_deprecated, Boolean, required: false, default_value: false
+      end
+      field :interfaces, [GraphQL::Schema::LateBoundType.new("__Type")]
+      field :possible_types, [GraphQL::Schema::LateBoundType.new("__Type")]
+      field :enum_values, [GraphQL::Schema::LateBoundType.new("__EnumValue")] do
+        argument :include_deprecated, Boolean, required: false, default_value: false
+      end
+      field :input_fields, [GraphQL::Schema::LateBoundType.new("__InputValue")]  do
+        argument :include_deprecated, Boolean, required: false, default_value: false
+      end
+      field :of_type, GraphQL::Schema::LateBoundType.new("__Type")
 
-  field :kind do
-    type !GraphQL::Introspection::TypeKindEnum
-    description "The kind of this type"
-    resolve -> (target, a, c) { target.kind.name }
-  end
+      field :specifiedByURL, String, resolver_method: :specified_by_url
+
+      field :is_one_of, Boolean, null: false
+
+      def is_one_of
+        object.kind.input_object? &&
+          object.directives.any? { |d| d.graphql_name == "oneOf" }
+      end
+
+      def specified_by_url
+        if object.kind.scalar?
+          object.specified_by_url
+        else
+          nil
+        end
+      end
+
+      def kind
+        @object.kind.name
+      end
+
+      def enum_values(include_deprecated:)
+        if !@object.kind.enum?
+          nil
+        else
+          enum_values = @context.warden.enum_values(@object)
+
+          if !include_deprecated
+            enum_values = enum_values.select {|f| !f.deprecation_reason }
+          end
 
-  field :fields,          field: GraphQL::Introspection::FieldsField
-  field :ofType,          field: GraphQL::Introspection::OfTypeField
-  field :inputFields,     field: GraphQL::Introspection::InputFieldsField
-  field :possibleTypes,   field: GraphQL::Introspection::PossibleTypesField
-  field :enumValues,      field: GraphQL::Introspection::EnumValuesField
-  field :interfaces,      field: GraphQL::Introspection::InterfacesField
+          enum_values
+        end
+      end
+
+      def interfaces
+        if @object.kind.object? || @object.kind.interface?
+          @context.warden.interfaces(@object).sort_by(&:graphql_name)
+        else
+          nil
+        end
+      end
+
+      def input_fields(include_deprecated:)
+        if @object.kind.input_object?
+          args = @context.warden.arguments(@object)
+          args = args.reject(&:deprecation_reason) unless include_deprecated
+          args
+        else
+          nil
+        end
+      end
+
+      def possible_types
+        if @object.kind.abstract?
+          @context.warden.possible_types(@object).sort_by(&:graphql_name)
+        else
+          nil
+        end
+      end
+
+      def fields(include_deprecated:)
+        if !@object.kind.fields?
+          nil
+        else
+          fields = @context.warden.fields(@object)
+          if !include_deprecated
+            fields = fields.select {|f| !f.deprecation_reason }
+          end
+          fields.sort_by(&:name)
+        end
+      end
+
+      def of_type
+        @object.kind.wraps? ? @object.of_type : nil
+      end
+    end
+  end
 end

data/lib/graphql/introspection.rb

@@ -1,27 +1,118 @@
+# frozen_string_literal: true
 module GraphQL
   module Introspection
+    def self.query(include_deprecated_args: false, include_schema_description: false, include_is_repeatable: false, include_specified_by_url: false, include_is_one_of: false)
+      # The introspection query to end all introspection queries, copied from
+      # https://github.com/graphql/graphql-js/blob/master/src/utilities/introspectionQuery.js
+      <<-QUERY.gsub(/\n{2,}/, "\n")
+query IntrospectionQuery {
+  __schema {
+    #{include_schema_description ? "description" : ""}
+    queryType { name }
+    mutationType { name }
+    subscriptionType { name }
+    types {
+      ...FullType
+    }
+    directives {
+      name
+      description
+      locations
+      #{include_is_repeatable ? "isRepeatable" : ""}
+      args#{include_deprecated_args ? '(includeDeprecated: true)' : ''} {
+        ...InputValue
+      }
+    }
+  }
+}
+fragment FullType on __Type {
+  kind
+  name
+  description
+  #{include_specified_by_url ? "specifiedByURL" : ""}
+  #{include_is_one_of ? "isOneOf" : ""}
+  fields(includeDeprecated: true) {
+    name
+    description
+    args#{include_deprecated_args ? '(includeDeprecated: true)' : ''} {
+      ...InputValue
+    }
+    type {
+      ...TypeRef
+    }
+    isDeprecated
+    deprecationReason
+  }
+  inputFields#{include_deprecated_args ? '(includeDeprecated: true)' : ''} {
+    ...InputValue
+  }
+  interfaces {
+    ...TypeRef
+  }
+  enumValues(includeDeprecated: true) {
+    name
+    description
+    isDeprecated
+    deprecationReason
+  }
+  possibleTypes {
+    ...TypeRef
+  }
+}
+fragment InputValue on __InputValue {
+  name
+  description
+  type { ...TypeRef }
+  defaultValue
+  #{include_deprecated_args ? 'isDeprecated' : ''}
+  #{include_deprecated_args ? 'deprecationReason' : ''}
+}
+fragment TypeRef on __Type {
+  kind
+  name
+  ofType {
+    kind
+    name
+    ofType {
+      kind
+      name
+      ofType {
+        kind
+        name
+        ofType {
+          kind
+          name
+          ofType {
+            kind
+            name
+            ofType {
+              kind
+              name
+              ofType {
+                kind
+                name
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+}
+      QUERY
+    end
   end
 end
 
-require "graphql/introspection/typename_field"
+require "graphql/introspection/base_object"
 require "graphql/introspection/input_value_type"
 require "graphql/introspection/enum_value_type"
 require "graphql/introspection/type_kind_enum"
-
-require "graphql/introspection/fields_field"
-require "graphql/introspection/of_type_field"
-require "graphql/introspection/input_fields_field"
-require "graphql/introspection/possible_types_field"
-require "graphql/introspection/enum_values_field"
-require "graphql/introspection/interfaces_field"
-
 require "graphql/introspection/type_type"
-require "graphql/introspection/arguments_field"
 require "graphql/introspection/field_type"
-
 require "graphql/introspection/directive_location_enum"
 require "graphql/introspection/directive_type"
 require "graphql/introspection/schema_type"
-require "graphql/introspection/schema_field"
-require "graphql/introspection/type_by_name_field"
 require "graphql/introspection/introspection_query"
+require "graphql/introspection/dynamic_fields"
+require "graphql/introspection/entry_points"

data/lib/graphql/invalid_name_error.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+module GraphQL
+  class InvalidNameError < GraphQL::ExecutionError
+    attr_reader :name, :valid_regex
+    def initialize(name, valid_regex)
+      @name = name
+      @valid_regex = valid_regex
+      super("Names must match #{@valid_regex.inspect} but '#{@name}' does not")
+    end
+  end
+end

data/lib/graphql/invalid_null_error.rb

@@ -1,22 +1,50 @@
+# frozen_string_literal: true
 module GraphQL
   # Raised automatically when a field's resolve function returns `nil`
   # for a non-null field.
-  class InvalidNullError < GraphQL::Error
-    def initialize(field_name, value)
-      @field_name = field_name
+  class InvalidNullError < GraphQL::RuntimeTypeError
+    # @return [GraphQL::BaseType] The owner of {#field}
+    attr_reader :parent_type
+
+    # @return [GraphQL::Field] The field which failed to return a value
+    attr_reader :field
+
+    # @return [nil, GraphQL::ExecutionError] The invalid value for this field
+    attr_reader :value
+
+    def initialize(parent_type, field, value)
+      @parent_type = parent_type
+      @field = field
       @value = value
+      super("Cannot return null for non-nullable field #{@parent_type.graphql_name}.#{@field.graphql_name}")
     end
 
     # @return [Hash] An entry for the response's "errors" key
     def to_h
-      {
-        "message" => "Cannot return null for non-nullable field #{@field_name}"
-      }
+      { "message" => message }
     end
 
-    # @return [Boolean] Whether the null in question was caused by another error
+    # @deprecated always false
     def parent_error?
-      @value.is_a?(GraphQL::ExecutionError)
+      false
+    end
+
+    class << self
+      attr_accessor :parent_class
+
+      def subclass_for(parent_class)
+        subclass = Class.new(self)
+        subclass.parent_class = parent_class
+        subclass
+      end
+
+      def inspect
+        if (name.nil? || parent_class.name.nil?) && parent_class.respond_to?(:mutation) && (mutation = parent_class.mutation)
+          "#{mutation.inspect}::#{parent_class.graphql_name}::InvalidNullError"
+        else
+          super
+        end
+      end
     end
   end
 end