graphql 1.8.0.pre2 → 1.8.0.pre3

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[:object_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/language.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+require "graphql/language/printer"
 require "graphql/language/definition_slice"
 require "graphql/language/document_from_schema_definition"
 require "graphql/language/generation"

data/lib/graphql/language/document_from_schema_definition.rb

@@ -6,10 +6,28 @@ module GraphQL
     # {GraphQL::Language::DocumentFromSchemaDefinition} is used to convert a {GraphQL::Schema} object
     # To a {GraphQL::Language::Document} AST node.
     #
+    # @param context [Hash]
+    # @param only [<#call(member, ctx)>]
+    # @param except [<#call(member, ctx)>]
+    # @param include_introspection_types [Boolean] Whether or not to include introspection types in the AST
+    # @param include_built_in_scalars [Boolean] Whether or not to include built in scalars in the AST
+    # @param include_built_in_directives [Boolean] Whether or not to include built in diirectives in the AST
     class DocumentFromSchemaDefinition
-      def initialize(schema)
+      def initialize(
+        schema, context: nil, only: nil, except: nil, include_introspection_types: false,
+        include_built_in_directives: false, include_built_in_scalars: false, always_include_schema: false
+      )
         @schema = schema
-        @types = GraphQL::Schema::Traversal.new(schema, introspection: true).type_map.values
+        @always_include_schema = always_include_schema
+        @include_introspection_types = include_introspection_types
+        @include_built_in_scalars = include_built_in_scalars
+        @include_built_in_directives = include_built_in_directives
+
+        @warden = GraphQL::Schema::Warden.new(
+          GraphQL::Filter.new(only: only, except: except),
+          schema: @schema,
+          context: context,
+        )
       end
 
       def document
@@ -18,47 +36,46 @@ module GraphQL
         )
       end
 
-      protected
-
-      def build_schema_node(schema)
-        schema_node = GraphQL::Language::Nodes::SchemaDefinition.new(
-          query: schema.query.name
+      def build_schema_node
+        GraphQL::Language::Nodes::SchemaDefinition.new(
+          query: warden.root_type_for_operation("query"),
+          mutation: warden.root_type_for_operation("mutation"),
+          subscription: warden.root_type_for_operation("subscription")
         )
-
-        if schema.mutation
-          schema_node.mutation = schema.mutation.name
-        end
-
-        if schema.subscription
-          schema_node.subscription = schema.subscription.name
-        end
-
-        schema_node
       end
 
       def build_object_type_node(object_type)
         GraphQL::Language::Nodes::ObjectTypeDefinition.new(
           name: object_type.name,
-          interfaces: object_type.interfaces.map { |iface| build_type_name_node(iface) },
-          fields: build_field_nodes(object_type.fields.values),
+          interfaces: warden.interfaces(object_type).sort_by(&:name).map { |iface| build_type_name_node(iface) },
+          fields: build_field_nodes(warden.fields(object_type)),
           description: object_type.description,
         )
       end
 
       def build_field_node(field)
-        GraphQL::Language::Nodes::FieldDefinition.new(
+        field_node = GraphQL::Language::Nodes::FieldDefinition.new(
           name: field.name,
-          arguments: build_argument_nodes(field.arguments.values),
+          arguments: build_argument_nodes(warden.arguments(field)),
           type: build_type_name_node(field.type),
           description: field.description,
         )
+
+        if field.deprecation_reason
+          field_node.directives << GraphQL::Language::Nodes::Directive.new(
+            name: GraphQL::Directive::DeprecatedDirective.name,
+            arguments: [GraphQL::Language::Nodes::Argument.new(name: "reason", value: field.deprecation_reason)]
+          )
+        end
+
+        field_node
       end
 
       def build_union_type_node(union_type)
         GraphQL::Language::Nodes::UnionTypeDefinition.new(
           name: union_type.name,
           description: union_type.description,
-          types: union_type.possible_types.map { |type| build_type_name_node(type) }
+          types: warden.possible_types(union_type).sort_by(&:name).map { |type| build_type_name_node(type) }
         )
       end
 
@@ -66,14 +83,14 @@ module GraphQL
         GraphQL::Language::Nodes::InterfaceTypeDefinition.new(
           name: interface_type.name,
           description: interface_type.description,
-          fields: build_field_nodes(interface_type.fields.values)
+          fields: build_field_nodes(warden.fields(interface_type))
         )
       end
 
       def build_enum_type_node(enum_type)
         GraphQL::Language::Nodes::EnumTypeDefinition.new(
           name: enum_type.name,
-          values: enum_type.values.values.map do |enum_value|
+          values: warden.enum_values(enum_type).sort_by(&:name).map do |enum_value|
             build_enum_value_node(enum_value)
           end,
           description: enum_type.description,
@@ -81,10 +98,19 @@ module GraphQL
       end
 
       def build_enum_value_node(enum_value)
-        GraphQL::Language::Nodes::EnumValueDefinition.new(
+        enum_value_node = GraphQL::Language::Nodes::EnumValueDefinition.new(
           name: enum_value.name,
           description: enum_value.description,
         )
+
+        if enum_value.deprecation_reason
+          enum_value_node.directives << GraphQL::Language::Nodes::Directive.new(
+            name: GraphQL::Directive::DeprecatedDirective.name,
+            arguments: [GraphQL::Language::Nodes::Argument.new(name: "reason", value: enum_value.deprecation_reason)]
+          )
+        end
+
+        enum_value_node
       end
 
       def build_scalar_type_node(scalar_type)
@@ -95,18 +121,23 @@ module GraphQL
       end
 
       def build_argument_node(argument)
-        GraphQL::Language::Nodes::InputValueDefinition.new(
+        argument_node = GraphQL::Language::Nodes::InputValueDefinition.new(
           name: argument.name,
           description: argument.description,
           type: build_type_name_node(argument.type),
-          default_value: argument.default_value,
         )
+
+        if argument.default_value?
+          argument_node.default_value = build_default_value(argument.default_value, argument.type)
+        end
+
+        argument_node
       end
 
       def build_input_object_node(input_object)
         GraphQL::Language::Nodes::InputObjectTypeDefinition.new(
           name: input_object.name,
-          fields: build_argument_nodes(input_object.arguments.values),
+          fields: build_argument_nodes(warden.arguments(input_object)),
           description: input_object.description,
         )
       end
@@ -114,7 +145,7 @@ module GraphQL
       def build_directive_node(directive)
         GraphQL::Language::Nodes::DirectiveDefinition.new(
           name: directive.name,
-          arguments: build_argument_nodes(directive.arguments.values),
+          arguments: build_argument_nodes(warden.arguments(directive)),
           locations: directive.locations.map(&:to_s),
           description: directive.description,
         )
@@ -135,6 +166,35 @@ module GraphQL
         end
       end
 
+      def build_default_value(default_value, type)
+        if default_value.nil?
+          return GraphQL::Language::Nodes::NullValue.new(name: "null")
+        end
+
+        case type
+        when GraphQL::ScalarType
+          default_value
+        when EnumType
+          GraphQL::Language::Nodes::Enum.new(name: type.coerce_isolated_result(default_value))
+        when InputObjectType
+          GraphQL::Language::Nodes::InputObject.new(
+            arguments: default_value.to_h.map do |arg_name, arg_value|
+              arg_type = type.input_fields.fetch(arg_name.to_s).type
+              GraphQL::Language::Nodes::Argument.new(
+                name: arg_name,
+                value: build_default_value(arg_value, arg_type)
+              )
+            end
+          )
+        when NonNullType
+          build_default_value(default_value, type.of_type)
+        when ListType
+          default_value.to_a.map { |v| build_default_value(v, type.of_type) }
+        else
+          raise NotImplementedError, "Unexpected default value type #{type.inspect}"
+        end
+      end
+
       def build_type_definition_node(type)
         case type
         when GraphQL::ObjectType
@@ -155,31 +215,63 @@ module GraphQL
       end
 
       def build_argument_nodes(arguments)
-        arguments.map { |arg| build_argument_node(arg) }
+        arguments
+          .map { |arg| build_argument_node(arg) }
+          .sort_by(&:name)
       end
 
       def build_directive_nodes(directives)
-        directives.map { |directive| build_directive_node(directive) }
+        if !include_built_in_directives
+          directives = directives.reject { |directive| directive.default_directive? }
+        end
+
+        directives
+          .map { |directive| build_directive_node(directive) }
+          .sort_by(&:name)
       end
 
       def build_definition_nodes
-        definitions = build_type_definition_nodes(types)
-        definitions += build_directive_nodes(schema.directives.values)
-        definitions << build_schema_node(schema)
+        definitions = []
+        definitions << build_schema_node if include_schema_node?
+        definitions += build_directive_nodes(warden.directives)
+        definitions += build_type_definition_nodes(warden.types)
         definitions
       end
 
       def build_type_definition_nodes(types)
-        types.map { |type| build_type_definition_node(type) }
+        if !include_introspection_types
+          types = types.reject { |type| type.introspection? }
+        end
+
+        if !include_built_in_scalars
+          types = types.reject { |type| type.default_scalar? }
+        end
+
+        types
+          .map { |type| build_type_definition_node(type) }
+          .sort_by(&:name)
       end
 
       def build_field_nodes(fields)
-        fields.map { |field| build_field_node(field) }
+        fields
+          .map { |field| build_field_node(field) }
+          .sort_by(&:name)
       end
 
       private
 
-      attr_reader :schema, :types
+      def include_schema_node?
+        always_include_schema || !schema_respects_root_name_conventions?(schema)
+      end
+
+      def schema_respects_root_name_conventions?(schema)
+        (schema.query.nil? || schema.query.name == 'Query') &&
+        (schema.mutation.nil? || schema.mutation.name == 'Mutation') &&
+        (schema.subscription.nil? || schema.subscription.name == 'Subscription')
+      end
+
+      attr_reader :schema, :warden, :always_include_schema,
+        :include_introspection_types, :include_built_in_directives, :include_built_in_scalars
     end
   end
 end

data/lib/graphql/language/generation.rb

@@ -14,189 +14,10 @@ module GraphQL
       #
       # @param node [GraphQL::Language::Nodes::AbstractNode] an AST node to recursively stringify
       # @param indent [String] Whitespace to add to each printed node
+      # @param printer [GraphQL::Language::Printer] An optional custom printer for printing AST nodes. Defaults to GraphQL::Language::Printer
       # @return [String] Valid GraphQL for `node`
-      def generate(node, indent: "")
-        case node
-        when Nodes::Document
-          node.definitions.map { |d| generate(d) }.join("\n\n")
-        when Nodes::Argument
-          "#{node.name}: #{generate(node.value)}".dup
-        when Nodes::Directive
-          out = "@#{node.name}".dup
-          out << "(#{node.arguments.map { |a| generate(a) }.join(", ")})" if node.arguments.any?
-          out
-        when Nodes::Enum
-          "#{node.name}".dup
-        when Nodes::NullValue
-          "null".dup
-        when Nodes::Field
-          out = "#{indent}".dup
-          out << "#{node.alias}: " if node.alias
-          out << "#{node.name}"
-          out << "(#{node.arguments.map { |a| generate(a) }.join(", ")})" if node.arguments.any?
-          out << generate_directives(node.directives)
-          out << generate_selections(node.selections, indent: indent)
-          out
-        when Nodes::FragmentDefinition
-          out = "#{indent}fragment #{node.name}".dup
-          if node.type
-            out << " on #{generate(node.type)}"
-          end
-          out << generate_directives(node.directives)
-          out << generate_selections(node.selections, indent: indent)
-          out
-        when Nodes::FragmentSpread
-          out = "#{indent}...#{node.name}".dup
-          out << generate_directives(node.directives)
-          out
-        when Nodes::InlineFragment
-          out = "#{indent}...".dup
-          if node.type
-            out << " on #{generate(node.type)}"
-          end
-          out << generate_directives(node.directives)
-          out << generate_selections(node.selections, indent: indent)
-          out
-        when Nodes::InputObject
-          generate(node.to_h)
-        when Nodes::ListType
-          "[#{generate(node.of_type)}]".dup
-        when Nodes::NonNullType
-          "#{generate(node.of_type)}!".dup
-        when Nodes::OperationDefinition
-          out = "#{indent}#{node.operation_type}".dup
-          out << " #{node.name}" if node.name
-          out << "(#{node.variables.map { |v| generate(v) }.join(", ")})" if node.variables.any?
-          out << generate_directives(node.directives)
-          out << generate_selections(node.selections, indent: indent)
-          out
-        when Nodes::TypeName
-          "#{node.name}".dup
-        when Nodes::VariableDefinition
-          out = "$#{node.name}: #{generate(node.type)}".dup
-          out << " = #{generate(node.default_value)}" unless node.default_value.nil?
-          out
-        when Nodes::VariableIdentifier
-          "$#{node.name}".dup
-        when Nodes::SchemaDefinition
-          if (node.query.nil? || node.query == 'Query') &&
-             (node.mutation.nil? || node.mutation == 'Mutation') &&
-             (node.subscription.nil? || node.subscription == 'Subscription')
-            return
-          end
-
-          out = "schema {\n".dup
-          out << "  query: #{node.query}\n" if node.query
-          out << "  mutation: #{node.mutation}\n" if node.mutation
-          out << "  subscription: #{node.subscription}\n" if node.subscription
-          out << "}"
-        when Nodes::ScalarTypeDefinition
-          out = generate_description(node)
-          out << "scalar #{node.name}"
-          out << generate_directives(node.directives)
-        when Nodes::ObjectTypeDefinition
-          out = generate_description(node)
-          out << "type #{node.name}"
-          out << generate_directives(node.directives)
-          out << " implements " << node.interfaces.map(&:name).join(", ") unless node.interfaces.empty?
-          out << generate_field_definitions(node.fields)
-        when Nodes::InputValueDefinition
-          out = "#{node.name}: #{generate(node.type)}".dup
-          out << " = #{generate(node.default_value)}" unless node.default_value.nil?
-          out << generate_directives(node.directives)
-        when Nodes::FieldDefinition
-          out = node.name.dup
-          unless node.arguments.empty?
-            out << "(" << node.arguments.map{ |arg| generate(arg) }.join(", ") << ")"
-          end
-          out << ": #{generate(node.type)}"
-          out << generate_directives(node.directives)
-        when Nodes::InterfaceTypeDefinition
-          out = generate_description(node)
-          out << "interface #{node.name}"
-          out << generate_directives(node.directives)
-          out << generate_field_definitions(node.fields)
-        when Nodes::UnionTypeDefinition
-          out = generate_description(node)
-          out << "union #{node.name}"
-          out << generate_directives(node.directives)
-          out << " = " + node.types.map(&:name).join(" | ")
-        when Nodes::EnumTypeDefinition
-          out = generate_description(node)
-          out << "enum #{node.name}#{generate_directives(node.directives)} {\n"
-          node.values.each.with_index do |value, i|
-            out << generate_description(value, indent: '  ', first_in_block: i == 0)
-            out << generate(value)
-          end
-          out << "}"
-        when Nodes::EnumValueDefinition
-          out = "  #{node.name}".dup
-          out << generate_directives(node.directives)
-          out << "\n"
-        when Nodes::InputObjectTypeDefinition
-          out = generate_description(node)
-          out << "input #{node.name}"
-          out << generate_directives(node.directives)
-          out << " {\n"
-          node.fields.each.with_index do |field, i|
-            out << generate_description(field, indent: '  ', first_in_block: i == 0)
-            out << "  #{generate(field)}\n"
-          end
-          out << "}"
-        when Nodes::DirectiveDefinition
-          out = generate_description(node)
-          out << "directive @#{node.name}"
-          out << "(#{node.arguments.map { |a| generate(a) }.join(", ")})" if node.arguments.any?
-          out << " on #{node.locations.join(' | ')}"
-        when Nodes::AbstractNode
-          node.to_query_string(indent: indent)
-        when FalseClass, Float, Integer, NilClass, String, TrueClass
-          GraphQL::Language.serialize(node)
-        when Array
-          "[#{node.map { |v| generate(v) }.join(", ")}]".dup
-        when Hash
-          "{#{node.map { |k, v| "#{k}: #{generate(v)}" }.join(", ")}}".dup
-        else
-          raise TypeError
-        end
-      end
-
-      private
-
-      def generate_directives(directives)
-        if directives.any?
-          directives.map { |d| " #{generate(d)}" }.join
-        else
-          ""
-        end
-      end
-
-      def generate_selections(selections, indent: "")
-        if selections.any?
-          out = " {\n".dup
-          selections.each do |selection|
-            out << generate(selection, indent: indent + "  ") << "\n"
-          end
-          out << "#{indent}}"
-        else
-          ""
-        end
-      end
-
-      def generate_description(node, indent: '', first_in_block: true)
-        return ''.dup unless node.description
-
-        description = indent != '' && !first_in_block ? "\n".dup : "".dup
-        description << GraphQL::Language::Comments.commentize(node.description, indent: indent)
-      end
-
-      def generate_field_definitions(fields)
-        out = " {\n".dup
-        fields.each.with_index do |field, i|
-          out << generate_description(field, indent: '  ', first_in_block: i == 0)
-          out << "  #{generate(field)}\n"
-        end
-        out << "}"
+      def generate(node, indent: "", printer: GraphQL::Language::Printer.new)
+        printer.print(node, indent: indent)
       end
     end
   end