graphql 1.7.6 → 1.8.0

data/lib/graphql/introspection/field_type.rb

@@ -1,15 +1,24 @@
 # frozen_string_literal: true
-GraphQL::Introspection::FieldType = GraphQL::ObjectType.define do
-  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, !types.String
-  field :description, types.String
-  field :args, GraphQL::Introspection::ArgumentsField
-  field :type, !GraphQL::Introspection::TypeType
-  field :isDeprecated, !types.Boolean do
-    resolve ->(obj, a, c) { !!obj.deprecation_reason }
+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, null: true
+      field :args, [GraphQL::Schema::LateBoundType.new("__InputValue")], null: false
+      field :type, GraphQL::Schema::LateBoundType.new("__Type"), null: false
+      field :is_deprecated, Boolean, null: false
+      field :deprecation_reason, String, null: true
+
+      def is_deprecated
+        !!@object.deprecation_reason
+      end
+
+      def args
+        @context.warden.arguments(@object)
+      end
+    end
   end
-  field :deprecationReason, types.String, property: :deprecation_reason
-  introspection true
 end

data/lib/graphql/introspection/input_value_type.rb

@@ -1,30 +1,33 @@
 # frozen_string_literal: true
-GraphQL::Introspection::InputValueType = GraphQL::ObjectType.define do
-  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, !types.String
-  field :description, types.String
-  field :type, !GraphQL::Introspection::TypeType
-  field :defaultValue, types.String, "A GraphQL-formatted string representing the default value for this input value." do
-    resolve ->(obj, args, ctx) {
-      if obj.default_value?
-        value = obj.default_value
-        if value.nil?
-          'null'
-        else
-          coerced_default_value = obj.type.coerce_result(value, ctx)
-          if obj.type.unwrap.is_a?(GraphQL::EnumType)
-            coerced_default_value
+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, null: true
+      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.", null: true
+
+      def default_value
+        if @object.default_value?
+          value = @object.default_value
+          if value.nil?
+            'null'
           else
-            GraphQL::Language.serialize(coerced_default_value)
+            coerced_default_value = @object.type.coerce_result(value, @context)
+            if @object.type.unwrap.is_a?(GraphQL::EnumType)
+              coerced_default_value
+            else
+              GraphQL::Language.serialize(coerced_default_value)
+            end
           end
+        else
+          nil
         end
-      else
-        nil
       end
-    }
+    end
   end
-  introspection true
 end

data/lib/graphql/introspection/schema_field.rb

@@ -4,8 +4,13 @@ module GraphQL
     SchemaField = GraphQL::Field.define do
       name("__schema")
       description("This GraphQL schema")
-      type(!GraphQL::Introspection::SchemaType)
-      resolve ->(o, a, ctx) { ctx.query.schema }
+      type(GraphQL::Schema::LateBoundType.new("__Schema").to_non_null_type)
+      resolve ->(o, a, ctx) {
+        # Apply wrapping manually since this field isn't wrapped by instrumentation
+        schema = ctx.query.schema
+        schema_type = schema.introspection_system.schema_type
+        schema_type.metadata[:type_class].new(schema, ctx.query.context)
+      }
     end
   end
 end

data/lib/graphql/introspection/schema_type.rb

@@ -1,29 +1,43 @@
 # frozen_string_literal: true
-GraphQL::Introspection::SchemaType = GraphQL::ObjectType.define do
-  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 :types, !types[!GraphQL::Introspection::TypeType], "A list of all types supported by this server." do
-    resolve ->(obj, arg, ctx) { ctx.warden.types }
-  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 :queryType, !GraphQL::Introspection::TypeType, "The type that query operations will be rooted at." do
-    resolve ->(obj, arg, ctx) { ctx.warden.root_type_for_operation("query") }
-  end
+      field :types, [GraphQL::Schema::LateBoundType.new("__Type")], "A list of all types supported by this server.", null: false
+      field :queryType, GraphQL::Schema::LateBoundType.new("__Type"), "The type that query operations will be rooted at.", null: false
+      field :mutationType, GraphQL::Schema::LateBoundType.new("__Type"), "If this server supports mutation, the type that mutation operations will be rooted at.", null: true
+      field :subscriptionType, GraphQL::Schema::LateBoundType.new("__Type"), "If this server support subscription, the type that subscription operations will be rooted at.", null: true
+      field :directives, [GraphQL::Schema::LateBoundType.new("__Directive")], "A list of all directives supported by this server.", null: false
 
-  field :mutationType, GraphQL::Introspection::TypeType, "If this server supports mutation, the type that mutation operations will be rooted at." do
-    resolve ->(obj, arg, ctx) { ctx.warden.root_type_for_operation("mutation") }
-  end
+      def types
+        @context.warden.types
+      end
 
-  field :subscriptionType, GraphQL::Introspection::TypeType, "If this server support subscription, the type that subscription operations will be rooted at." do
-    resolve ->(obj, arg, ctx) { ctx.warden.root_type_for_operation("subscription") }
-  end
+      def query_type
+        permitted_root_type("query")
+      end
 
-  field :directives, !types[!GraphQL::Introspection::DirectiveType], "A list of all directives supported by this server." do
-    resolve ->(obj, arg, ctx) { obj.directives.values }
-  end
+      def mutation_type
+        permitted_root_type("mutation")
+      end
 
-  introspection true
+      def subscription_type
+        permitted_root_type("subscription")
+      end
+
+      def directives
+        @object.directives.values
+      end
+
+      private
+
+      def permitted_root_type(op_type)
+        @context.warden.root_type_for_operation(op_type)
+      end
+    end
+  end
 end

data/lib/graphql/introspection/type_by_name_field.rb

@@ -4,10 +4,18 @@ module GraphQL
     TypeByNameField = GraphQL::Field.define do
       name("__type")
       description("A type in the GraphQL system")
-      type(GraphQL::Introspection::TypeType)
+      introspection true
+      type(GraphQL::Schema::LateBoundType.new("__Type"))
       argument :name, !types.String
       resolve ->(o, args, ctx) {
-        ctx.warden.get_type(args["name"])
+        type = ctx.warden.get_type(args["name"])
+        if type
+          # Apply wrapping manually since this field isn't wrapped by instrumentation
+          type_type = ctx.schema.introspection_system.type_type
+          type_type.metadata[:type_class].new(type, ctx)
+        else
+          nil
+        end
       }
     end
   end

data/lib/graphql/introspection/type_kind_enum.rb

@@ -1,9 +1,13 @@
 # frozen_string_literal: true
-GraphQL::Introspection::TypeKindEnum = GraphQL::EnumType.define do
-  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)
+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
-  introspection true
 end

data/lib/graphql/introspection/type_type.rb

@@ -1,26 +1,88 @@
 # frozen_string_literal: true
-GraphQL::Introspection::TypeType = GraphQL::ObjectType.define do
-  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 :kind do
-    type !GraphQL::Introspection::TypeKindEnum
-    resolve ->(target, a, c) { target.kind.name }
-  end
+module GraphQL
+  module Introspection
+    class TypeType < GraphQL::Schema::Object
+      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 :kind, GraphQL::Schema::LateBoundType.new("__TypeKind"), null: false
+      field :name, String, null: true
+      field :description, String, null: true
+      field :fields, [GraphQL::Schema::LateBoundType.new("__Field")], null: true do
+        argument :include_deprecated, Boolean, required: false, default_value: false
+      end
+      field :interfaces, [GraphQL::Schema::LateBoundType.new("__Type")], null: true
+      field :possible_types, [GraphQL::Schema::LateBoundType.new("__Type")], null: true
+      field :enum_values, [GraphQL::Schema::LateBoundType.new("__EnumValue")], null: true do
+        argument :include_deprecated, Boolean, required: false, default_value: false
+      end
+      field :input_fields, [GraphQL::Schema::LateBoundType.new("__InputValue")], null: true
+      field :of_type, GraphQL::Schema::LateBoundType.new("__Type"), null: true
+      introspection true
+
+      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
+
+          enum_values
+        end
+      end
 
-  field :name, types.String
-  field :description, types.String
-  field :fields,        GraphQL::Introspection::FieldsField
-  field :interfaces,    GraphQL::Introspection::InterfacesField
-  field :possibleTypes, GraphQL::Introspection::PossibleTypesField
-  field :enumValues,    GraphQL::Introspection::EnumValuesField
-  field :inputFields,   GraphQL::Introspection::InputFieldsField
-  field :ofType,        GraphQL::Introspection::OfTypeField
-  introspection true
+      def interfaces
+        if @object.kind == GraphQL::TypeKinds::OBJECT
+          @context.warden.interfaces(@object)
+        else
+          nil
+        end
+      end
+
+      def input_fields
+        if @object.kind.input_object?
+          @context.warden.arguments(@object)
+        else
+          nil
+        end
+      end
+
+      def possible_types
+        if @object.kind.resolves?
+          @context.warden.possible_types(@object)
+        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/typename_field.rb

@@ -5,6 +5,7 @@ module GraphQL
       name "__typename"
       description "The name of this type"
       type -> { !GraphQL::STRING_TYPE }
+      introspection true
       resolve ->(obj, a, ctx) { ctx.irep_node.owner_type }
     end
   end

data/lib/graphql/introspection.rb

@@ -4,25 +4,18 @@ module GraphQL
   end
 end
 
+require "graphql/introspection/base_object"
 require "graphql/introspection/typename_field"
 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/language/block_string.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+module GraphQL
+  module Language
+    module BlockString
+      # Remove leading and trailing whitespace from a block string.
+      # See "Block Strings" in https://github.com/facebook/graphql/blob/master/spec/Section%202%20--%20Language.md
+      def self.trim_whitespace(str)
+        lines = str.split("\n")
+        common_indent = nil
+
+        # find the common whitespace
+        lines.each_with_index do |line, idx|
+          if idx == 0
+            next
+          end
+          line_length = line.size
+          line_indent = line[/\A */].size
+          if line_indent < line_length && (common_indent.nil? || line_indent < common_indent)
+            common_indent = line_indent
+          end
+        end
+
+        # Remove the common whitespace
+        if common_indent
+          lines.each_with_index do |line, idx|
+            if idx == 0
+              next
+            else
+              line[0, common_indent] = ""
+            end
+          end
+        end
+
+        # Remove leading & trailing blank lines
+        while lines.first.empty?
+          lines.shift
+        end
+        while lines.last.empty?
+          lines.pop
+        end
+
+        # Rebuild the string
+        lines.join("\n")
+      end
+    end
+  end
+end