graphql 1.8.0.pre2 → 1.8.0.pre3

data/lib/graphql/version.rb

@@ -1,4 +1,4 @@
 # frozen_string_literal: true
 module GraphQL
-  VERSION = "1.8.0.pre2"
+  VERSION = "1.8.0.pre3"
 end

data/spec/fixtures/upgrader/blame_range.original.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module Platform
+  module Objects
+    BlameRange = GraphQL::ObjectType.define do
+      name "BlameRange"
+      description "Represents a range of information from a Git blame."
+
+      scopeless_tokens_as_minimum
+
+      # Test multiline interfaces
+      interfaces [
+        Interfaces::A,
+        Interfaces::B,
+      ]
+
+      field :startingLine, !types.Int do
+        description "The starting line for the range"
+
+        resolve ->(range, args, context) {
+          range.lines.first[:lineno]
+        }
+      end
+
+      field :endingLine, !types.Int do
+        description "The ending line for the range"
+
+        resolve ->(range, args, context) {
+          range.lines.first[:lineno] + (range.lines.length - 1)
+        }
+      end
+
+      field :commit, -> { !Objects::Commit } do
+        description "Identifies the line author"
+      end
+
+      field :age, !types.Int do
+        description "Identifies the recency of the change, from 1 (new) to 10 (old). This is calculated as a 2-quantile and determines the length of distance between the median age of all the changes in the file and the recency of the current range's change."
+        property :scale
+      end
+    end
+  end
+end

data/spec/fixtures/upgrader/blame_range.transformed.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Platform
+  module Objects
+    class BlameRange < Platform::Objects::Base
+      description "Represents a range of information from a Git blame."
+
+      scopeless_tokens_as_minimum
+
+      # Test multiline interfaces
+      implements Interfaces::A
+      implements Interfaces::B
+
+      field :starting_line, Integer, description: "The starting line for the range", null: false
+
+      def starting_line
+        @object.lines.first[:lineno]
+      end
+
+      field :ending_line, Integer, description: "The ending line for the range", null: false
+
+      def ending_line
+        @object.lines.first[:lineno] + (@object.lines.length - 1)
+      end
+
+      field :commit, Objects::Commit, description: "Identifies the line author", null: false
+
+      field :age, Integer, method: :scale, description: "Identifies the recency of the change, from 1 (new) to 10 (old). This is calculated as a 2-quantile and determines the length of distance between the median age of all the changes in the file and the recency of the current range's change.", null: false
+    end
+  end
+end

data/spec/fixtures/upgrader/subscribable.original.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module Platform
+  module Interfaces
+    Subscribable = GraphQL::InterfaceType.define do
+      name "Subscribable"
+      description "Entities that can be subscribed to for web and email notifications."
+
+      field :id, !GraphQL::ID_TYPE, property: :global_relay_id
+
+      field :viewerSubscription, -> { !Enums::SubscriptionState } do
+        description "Identifies if the viewer is watching, not watching, or ignoring the subscribable entity."
+
+        resolve ->(subscribable, arguments, context) do
+          if context[:viewer].nil?
+            return "unsubscribed"
+          end
+
+          subscription_status_response = subscribable.async_subscription_status(context[:viewer]).sync
+
+          if subscription_status_response.failed?
+            error = Platform::Errors::ServiceUnavailable.new("Subscriptions are currently unavailable. Please try again later.")
+            error.ast_node = context.irep_node.ast_node
+            error.path = context.path
+            context.errors << error
+            return "unavailable"
+          end
+
+          subscription = subscription_status_response.value
+          if subscription.included?
+            "unsubscribed"
+          elsif subscription.subscribed?
+            "subscribed"
+          elsif subscription.ignored?
+            "ignored"
+          end
+        end
+      end
+
+      field :viewerCanSubscribe, !types.Boolean do
+        description "Check if the viewer is able to change their subscription status for the repository."
+
+        resolve ->(subscribable, arguments, context) do
+          return false if context[:viewer].nil?
+
+          subscribable.async_subscription_status(context[:viewer]).then(&:success?)
+        end
+      end
+    end
+  end
+end

data/spec/fixtures/upgrader/subscribable.transformed.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module Platform
+  module Interfaces
+    class Subscribable < Platform::Interfaces::Base
+      description "Entities that can be subscribed to for web and email notifications."
+
+      field :id, GraphQL::ID_TYPE, method: :global_relay_id, null: false
+
+      field :viewer_subscription, Enums::SubscriptionState, description: "Identifies if the viewer is watching, not watching, or ignoring the subscribable entity.", null: false
+
+      def viewer_subscription
+        if @context[:viewer].nil?
+          return "unsubscribed"
+        end
+
+        subscription_status_response = @object.async_subscription_status(@context[:viewer]).sync
+
+        if subscription_status_response.failed?
+          error = Platform::Errors::ServiceUnavailable.new("Subscriptions are currently unavailable. Please try again later.")
+          error.ast_node = @context.irep_node.ast_node
+          error.path = @context.path
+          @context.errors << error
+          return "unavailable"
+        end
+
+        subscription = subscription_status_response.value
+        if subscription.included?
+          "unsubscribed"
+        elsif subscription.subscribed?
+          "subscribed"
+        elsif subscription.ignored?
+          "ignored"
+        end
+      end
+
+      field :viewer_can_subscribe, Boolean, description: "Check if the viewer is able to change their subscription status for the repository.", null: false
+
+      def viewer_can_subscribe
+        return false if @context[:viewer].nil?
+
+        @object.async_subscription_status(@context[:viewer]).then(&:success?)
+      end
+    end
+  end
+end

data/spec/fixtures/upgrader/type_x.original.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module Platform
+  module Objects
+    X = define_active_record_type(-> { ::X }) do
+      name "X"
+      description "An x on a y."
+      visibility :internal
+      minimum_accepted_scopes ["z"]
+
+      global_id_field :id
+      interfaces [GraphQL::Relay::Node.interface]
+
+      field :f1, !Objects::O1, "The x being y."
+      field :f2, !Enums::E1, "x for the y.", property: :field_2
+      field :f3, Enums::E2, "x for y."
+      field :details, types.String, "Details."
+
+      field :f4, !Objects::O2, "x as a y inside the z." do
+        resolve ->(obj_x, arguments, context) do
+          Class1.new(
+            a: Class2.new(
+              b: obj_x.b_1,
+              c: obj_x.c_1
+            ),
+            d: Class3.new(
+              b: obj_x.b_2,
+              c: obj_x.c_3,
+            )
+          )
+        end
+      end
+    end
+  end
+end

data/spec/fixtures/upgrader/type_x.transformed.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module Platform
+  module Objects
+    class X < Platform::Objects::Base
+      model_name "X"
+      description "An x on a y."
+      visibility :internal
+      minimum_accepted_scopes ["z"]
+
+      global_id_field :id
+      implements GraphQL::Relay::Node.interface
+
+      field :f1, Objects::O1, "The x being y.", null: false
+      field :f2, Enums::E1, "x for the y.", method: :field_2, null: false
+      field :f3, Enums::E2, "x for y.", null: true
+      field :details, String, "Details.", null: true
+
+      field :f4, Objects::O2, "x as a y inside the z.", null: false
+
+      def f4
+        Class1.new(
+          a: Class2.new(
+            b: @object.b_1,
+            c: @object.c_1
+          ),
+          d: Class3.new(
+            b: @object.b_2,
+            c: @object.c_3,
+          )
+        )
+      end
+    end
+  end
+end

data/spec/graphql/language/document_from_schema_definition_spec.rb

@@ -2,316 +2,749 @@
 require "spec_helper"
 
 describe GraphQL::Language::DocumentFromSchemaDefinition do
-  let(:schema_idl) { <<-GRAPHQL
-    type QueryType {
-      foo: Foo
-    }
-
-    type Foo implements Bar {
-      one: Type
-      two(argument: InputType!): Type
-      three(argument: InputType, other: String): Int
-      four(argument: String = "string"): String
-      five(argument: [String] = ["string", "string"]): String
-      six(argument: String): Type
-    }
-
-    interface Bar {
-      one: Type
-      four(argument: String = "string"): String
-    }
-
-    type Type {
-      a: String
-    }
-
-    input InputType {
-      key: String!
-      answer: Int = 42
-    }
-
-    type MutationType {
-      a(input: InputType): String
-    }
-
-    # Scalar description
-    scalar CustomScalar
-
-    enum Site {
-      DESKTOP
-      MOBILE
-    }
-
-    union Union = Type | QueryType
-
-    schema {
-      query: QueryType
-      mutation: MutationType
-    }
-  GRAPHQL
-  }
-
-  let(:expected_complete_idl) { <<-GRAPHQL
-    # Represents `true` or `false` values.
-    scalar Boolean
-
-    # Represents textual data as UTF-8 character sequences. This type is most often
-    # used by GraphQL to represent free-form human-readable text.
-    scalar String
-
-    # The fundamental unit of any GraphQL Schema is the type. There are many kinds of
-    # types in GraphQL as represented by the `__TypeKind` enum.
-    #
-    # 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.
-    type __Type {
-      kind: __TypeKind!
-      name: String
-      description: String
-      fields(includeDeprecated: Boolean = false): [__Field!]
-      interfaces: [__Type!]
-      possibleTypes: [__Type!]
-      enumValues(includeDeprecated: Boolean = false): [__EnumValue!]
-      inputFields: [__InputValue!]
-      ofType: __Type
-    }
-
-    # An enum describing what kind of type a given `__Type` is.
-    enum __TypeKind {
-      # Indicates this type is a scalar.
-      SCALAR
-
-      # Indicates this type is an object. `fields` and `interfaces` are valid fields.
-      OBJECT
-
-      # Indicates this type is an interface. `fields` and `possibleTypes` are valid fields.
-      INTERFACE
-
-      # Indicates this type is a union. `possibleTypes` is a valid field.
-      UNION
-
-      # Indicates this type is an enum. `enumValues` is a valid field.
-      ENUM
-
-      # Indicates this type is an input object. `inputFields` is a valid field.
-      INPUT_OBJECT
-
-      # Indicates this type is a list. `ofType` is a valid field.
-      LIST
-
-      # Indicates this type is a non-null. `ofType` is a valid field.
-      NON_NULL
-    }
-
-    # 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.
-    type __Field {
-      name: String!
-      description: String
-      args: [__InputValue!]!
-      type: __Type!
-      isDeprecated: Boolean!
-      deprecationReason: String
-    }
-
-    # 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.
-    type __InputValue {
-      name: String!
-      description: String
-      type: __Type!
-
-      # A GraphQL-formatted string representing the default value for this input value.
-      defaultValue: String
-    }
-
-    # 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.
-    type __EnumValue {
-      name: String!
-      description: String
-      isDeprecated: Boolean!
-      deprecationReason: String
-    }
-
-    type QueryType {
-      foo: Foo
-    }
-
-    type Foo implements Bar {
-      one: Type
-      two(argument: InputType!): Type
-      three(argument: InputType, other: String): Int
-      four(argument: String = "string"): String
-      five(argument: [String] = ["string", "string"]): String
-      six(argument: String): Type
-    }
-
-    interface Bar {
-      one: Type
-      four(argument: String = "string"): String
-    }
-
-    type Type {
-      a: String
-    }
-
-    input InputType {
-      key: String!
-      answer: Int = 42
-    }
-
-    # Represents non-fractional signed whole numeric values. Int can represent values between -(2^31) and 2^31 - 1.
-    scalar Int
-
-    type MutationType {
-      a(input: InputType): String
-    }
-
-    # 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.
-    type __Schema {
-      # A list of all types supported by this server.
-      types: [__Type!]!
-
-      # The type that query operations will be rooted at.
-      queryType: __Type!
-
-      # If this server supports mutation, the type that mutation operations will be rooted at.
-      mutationType: __Type
-
-      # If this server support subscription, the type that subscription operations will be rooted at.
-      subscriptionType: __Type
-
-      # A list of all directives supported by this server.
-      directives: [__Directive!]!
-    }
+  let(:subject) { GraphQL::Language::DocumentFromSchemaDefinition }
 
-    # A Directive provides a way to describe alternate runtime execution and type validation behavior in a GraphQL document.
-    #
-    # In some cases, you need to provide options to alter GraphQL's execution behavior
-    # in ways field arguments will not suffice, such as conditionally including or
-    # skipping a field. Directives provide this by describing additional information
-    # to the executor.
-    type __Directive {
-      name: String!
-      description: String
-      locations: [__DirectiveLocation!]!
-      args: [__InputValue!]!
-      onOperation: Boolean!
-      onFragment: Boolean!
-      onField: Boolean!
+  describe "#document" do
+    let(:schema_idl) { <<-GRAPHQL
+      type QueryType {
+        foo: Foo
+      }
+
+      type Foo implements Bar {
+        one: Type
+        two(argument: InputType!): Site
+        three(argument: InputType, other: String): CustomScalar
+        four(argument: String = "string"): String
+        five(argument: [String] = ["string", "string"]): String
+        six(argument: String): Type
+      }
+
+      interface Bar {
+        one: Type
+        four(argument: String = "string"): String
+      }
+
+      type Type {
+        a: String
+      }
+
+      input InputType {
+        key: String!
+        answer: Int = 42
+      }
+
+      type MutationType {
+        a(input: InputType): String
+      }
+
+      # Scalar description
+      scalar CustomScalar
+
+      enum Site {
+        DESKTOP
+        MOBILE
+      }
+
+      union Union = Type | QueryType
+
+      schema {
+        query: QueryType
+        mutation: MutationType
+      }
+    GRAPHQL
     }
 
-    # A Directive can be adjacent to many parts of the GraphQL language, a
-    # __DirectiveLocation describes one such possible adjacencies.
-    enum __DirectiveLocation {
-      # Location adjacent to a query operation.
-      QUERY
-
-      # Location adjacent to a mutation operation.
-      MUTATION
-
-      # Location adjacent to a subscription operation.
-      SUBSCRIPTION
-
-      # Location adjacent to a field.
-      FIELD
-
-      # Location adjacent to a fragment definition.
-      FRAGMENT_DEFINITION
-
-      # Location adjacent to a fragment spread.
-      FRAGMENT_SPREAD
-
-      # Location adjacent to an inline fragment.
-      INLINE_FRAGMENT
-
-      # Location adjacent to a schema definition.
-      SCHEMA
-
-      # Location adjacent to a scalar definition.
-      SCALAR
-
-      # Location adjacent to an object type definition.
-      OBJECT
-
-      # Location adjacent to a field definition.
-      FIELD_DEFINITION
-
-      # Location adjacent to an argument definition.
-      ARGUMENT_DEFINITION
-
-      # Location adjacent to an interface definition.
-      INTERFACE
-
-      # Location adjacent to a union definition.
-      UNION
-
-      # Location adjacent to an enum definition.
-      ENUM
-
-      # Location adjacent to an enum value definition.
-      ENUM_VALUE
+    let(:schema) { GraphQL::Schema.from_definition(schema_idl) }
+
+    let(:expected_document) { GraphQL.parse(expected_idl) }
+
+    describe "when printing and schema respects root name conventions" do
+      let(:schema_idl) { <<-GRAPHQL
+        type Query {
+          foo: Foo
+        }
+
+        type Foo implements Bar {
+          one: Type
+          two(argument: InputType!): Site
+          three(argument: InputType, other: String): CustomScalar
+          four(argument: String = "string"): String
+          five(argument: [String] = ["string", "string"]): String
+          six(argument: String): Type
+        }
+
+        interface Bar {
+          one: Type
+          four(argument: String = "string"): String
+        }
+
+        type Type {
+          a: String
+        }
+
+        input InputType {
+          key: String!
+          answer: Int = 42
+        }
+
+        type Mutation {
+          a(input: InputType): String
+        }
+
+        # Scalar description
+        scalar CustomScalar
+
+        enum Site {
+          DESKTOP
+          MOBILE
+        }
+
+        union Union = Type | Query
+
+        schema {
+          query: Query
+          mutation: Mutation
+        }
+      GRAPHQL
+      }
+
+      let(:expected_idl) { <<-GRAPHQL
+        type QueryType {
+          foo: Foo
+        }
+
+        type Foo implements Bar {
+          one: Type
+          two(argument: InputType!): Site
+          three(argument: InputType, other: String): CustomScalar
+          four(argument: String = "string"): String
+          five(argument: [String] = ["string", "string"]): String
+          six(argument: String): Type
+        }
+
+        interface Bar {
+          one: Type
+          four(argument: String = "string"): String
+        }
+
+        type Type {
+          a: String
+        }
+
+        input InputType {
+          key: String!
+          answer: Int = 42
+        }
+
+        type MutationType {
+          a(input: InputType): String
+        }
+
+        # Scalar description
+        scalar CustomScalar
+
+        enum Site {
+          DESKTOP
+          MOBILE
+        }
+
+        union Union = Type | QueryType
+      GRAPHQL
+      }
+
+      let(:document) {
+        subject.new(
+          schema
+        ).document
+      }
+
+      it "returns the IDL without introspection, built ins and schema root" do
+        assert equivalent_node?(expected_document, document)
+      end
+    end
 
-      # Location adjacent to an input object type definition.
-      INPUT_OBJECT
+    describe "with defaults" do
+      let(:expected_idl) { <<-GRAPHQL
+        type QueryType {
+          foo: Foo
+        }
+
+        type Foo implements Bar {
+          one: Type
+          two(argument: InputType!): Site
+          three(argument: InputType, other: String): CustomScalar
+          four(argument: String = "string"): String
+          five(argument: [String] = ["string", "string"]): String
+          six(argument: String): Type
+        }
+
+        interface Bar {
+          one: Type
+          four(argument: String = "string"): String
+        }
+
+        type Type {
+          a: String
+        }
+
+        input InputType {
+          key: String!
+          answer: Int = 42
+        }
+
+        type MutationType {
+          a(input: InputType): String
+        }
+
+        # Scalar description
+        scalar CustomScalar
+
+        enum Site {
+          DESKTOP
+          MOBILE
+        }
+
+        union Union = Type | QueryType
+
+        schema {
+          query: QueryType
+          mutation: MutationType
+        }
+      GRAPHQL
+      }
+
+      let(:document) {
+        subject.new(
+          schema
+        ).document
+      }
+
+      it "returns the IDL without introspection, built ins and schema if it doesnt respect name conventions" do
+        assert equivalent_node?(expected_document, document)
+      end
+    end
 
-      # Location adjacent to an input object field definition.
-      INPUT_FIELD_DEFINITION
-    }
+    describe "with an except filter" do
+      let(:expected_idl) { <<-GRAPHQL
+        type QueryType {
+          foo: Foo
+        }
+
+        type Foo implements Bar {
+          three(argument: InputType, other: String): CustomScalar
+          four(argument: String = "string"): String
+          five(argument: [String] = ["string", "string"]): Site
+        }
+
+        interface Bar {
+          one: Type
+          four(argument: String = "string"): String
+        }
+
+        input InputType {
+          key: String!
+          answer: Int = 42
+        }
+
+        type MutationType {
+          a(input: InputType): String
+        }
+
+        # Scalar description
+        scalar CustomScalar
+
+        enum Site {
+          DESKTOP
+          MOBILE
+        }
+
+        schema {
+          query: QueryType
+          mutation: MutationType
+        }
+      GRAPHQL
+      }
+
+      let(:document) {
+        subject.new(
+          schema,
+          except: ->(m, _ctx) { m.is_a?(GraphQL::BaseType) && m.name == "Type" }
+        ).document
+      }
+
+      it "returns the IDL minus the filtered members" do
+        assert equivalent_node?(expected_document, document)
+      end
+    end
 
-    # Represents signed double-precision fractional values as specified by [IEEE
-    # 754](http://en.wikipedia.org/wiki/IEEE_floating_point).
-    scalar Float
+    describe "with an only filter" do
+      let(:expected_idl) { <<-GRAPHQL
+        type QueryType {
+          foo: Foo
+        }
+
+        type Foo implements Bar {
+          three(argument: InputType, other: String): CustomScalar
+          four(argument: String = "string"): String
+          five(argument: [String] = ["string", "string"]): Site
+        }
+
+        interface Bar {
+          one: Type
+          four(argument: String = "string"): String
+        }
+
+        input InputType {
+          key: String!
+          answer: Int = 42
+        }
+
+        type MutationType {
+          a(input: InputType): String
+        }
+
+        enum Site {
+          DESKTOP
+          MOBILE
+        }
+
+        schema {
+          query: QueryType
+          mutation: MutationType
+        }
+      GRAPHQL
+      }
+
+      let(:document) {
+        subject.new(
+          schema,
+          only: ->(m, _ctx) { !(m.is_a?(GraphQL::ScalarType) && m.name == "CustomScalar") }
+        ).document
+      }
+
+      it "returns the IDL minus the filtered members" do
+        assert equivalent_node?(expected_document, document)
+      end
+    end
 
-    # Represents a unique identifier that is Base64 obfuscated. It is often used to
-    # refetch an object or as key for a cache. The ID type appears in a JSON response
-    # as a String; however, it is not intended to be human-readable. When expected as
-    # an input type, any string (such as `"VXNlci0xMA=="`) or integer (such as `4`)
-    # input value will be accepted as an ID.
-    scalar ID
+    describe "when excluding built ins and introspection types" do
+      let(:expected_idl) { <<-GRAPHQL
+        type QueryType {
+          foo: Foo
+        }
+
+        type Foo implements Bar {
+          one: Type
+          two(argument: InputType!): Site
+          three(argument: InputType, other: String): CustomScalar
+          four(argument: String = "string"): String
+          five(argument: [String] = ["string", "string"]): String
+          six(argument: String): Type
+        }
+
+        interface Bar {
+          one: Type
+          four(argument: String = "string"): String
+        }
+
+        type Type {
+          a: String
+        }
+
+        input InputType {
+          key: String!
+          answer: Int = 42
+        }
+
+        type MutationType {
+          a(input: InputType): String
+        }
+
+        # Scalar description
+        scalar CustomScalar
+
+        enum Site {
+          DESKTOP
+          MOBILE
+        }
+
+        union Union = Type | QueryType
+
+        schema {
+          query: QueryType
+          mutation: MutationType
+        }
+      GRAPHQL
+      }
+
+      let(:document) {
+        subject.new(
+          schema,
+          always_include_schema: true
+        ).document
+      }
+
+      it "returns the schema idl besides introspection types and built ins" do
+        assert equivalent_node?(expected_document, document)
+      end
+    end
 
-    # Scalar description
-    scalar CustomScalar
+    describe "when printing excluding only introspection types" do
+      let(:expected_idl) { <<-GRAPHQL
+        # Represents `true` or `false` values.
+        scalar Boolean
+
+        # Represents textual data as UTF-8 character sequences. This type is most often
+        # used by GraphQL to represent free-form human-readable text.
+        scalar String
+
+        type QueryType {
+          foo: Foo
+        }
+
+        type Foo implements Bar {
+          one: Type
+          two(argument: InputType!): Type
+          three(argument: InputType, other: String): CustomScalar
+          four(argument: String = "string"): String
+          five(argument: [String] = ["string", "string"]): String
+          six(argument: String): Type
+        }
+
+        interface Bar {
+          one: Type
+          four(argument: String = "string"): String
+        }
+
+        type Type {
+          a: String
+        }
+
+        input InputType {
+          key: String!
+          answer: Int = 42
+        }
+
+        # Represents non-fractional signed whole numeric values. Int can represent values between -(2^31) and 2^31 - 1.
+        scalar Int
+
+        type MutationType {
+          a(input: InputType): String
+        }
+
+        # Represents signed double-precision fractional values as specified by [IEEE
+        # 754](http://en.wikipedia.org/wiki/IEEE_floating_point).
+        scalar Float
+
+        # Represents a unique identifier that is Base64 obfuscated. It is often used to
+        # refetch an object or as key for a cache. The ID type appears in a JSON response
+        # as a String; however, it is not intended to be human-readable. When expected as
+        # an input type, any string (such as `"VXNlci0xMA=="`) or integer (such as `4`)
+        # input value will be accepted as an ID.
+        scalar ID
+
+        # Scalar description
+        scalar CustomScalar
+
+        enum Site {
+          DESKTOP
+          MOBILE
+        }
+
+        union Union = Type | QueryType
+
+        directive @skip(if: Boolean!) on FIELD | FRAGMENT_SPREAD | INLINE_FRAGMENT
+
+        directive @include(if: Boolean!) on FIELD | FRAGMENT_SPREAD | INLINE_FRAGMENT
+
+        # Marks an element of a GraphQL schema as no longer supported.
+        directive @deprecated(reason: String = "No longer supported") on FIELD_DEFINITION | ENUM_VALUE
+
+        schema {
+          query: QueryType
+          mutation: MutationType
+        }
+      GRAPHQL
+      }
+
+      let(:document) {
+        subject.new(
+          schema,
+          include_built_in_scalars: true,
+          include_built_in_directives: true,
+        ).document
+      }
+
+      it "returns the the schema IDL including only the built ins and not introspection types" do
+        assert equivalent_node?(expected_document, document)
+      end
+    end
 
-    enum Site {
-      DESKTOP
-      MOBILE
-    }
+    describe "when printing the full schema" do
+      let(:expected_idl) { <<-GRAPHQL
+        # Represents `true` or `false` values.
+        scalar Boolean
+
+        # Represents textual data as UTF-8 character sequences. This type is most often
+        # used by GraphQL to represent free-form human-readable text.
+        scalar String
+
+        # The fundamental unit of any GraphQL Schema is the type. There are many kinds of
+        # types in GraphQL as represented by the `__TypeKind` enum.
+        #
+        # 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.
+        type __Type {
+          kind: __TypeKind!
+          name: String
+          description: String
+          fields(includeDeprecated: Boolean = false): [__Field!]
+          interfaces: [__Type!]
+          possibleTypes: [__Type!]
+          enumValues(includeDeprecated: Boolean = false): [__EnumValue!]
+          inputFields: [__InputValue!]
+          ofType: __Type
+        }
+
+        # An enum describing what kind of type a given `__Type` is.
+        enum __TypeKind {
+          # Indicates this type is a scalar.
+          SCALAR
+
+          # Indicates this type is an object. `fields` and `interfaces` are valid fields.
+          OBJECT
+
+          # Indicates this type is an interface. `fields` and `possibleTypes` are valid fields.
+          INTERFACE
+
+          # Indicates this type is a union. `possibleTypes` is a valid field.
+          UNION
+
+          # Indicates this type is an enum. `enumValues` is a valid field.
+          ENUM
+
+          # Indicates this type is an input object. `inputFields` is a valid field.
+          INPUT_OBJECT
+
+          # Indicates this type is a list. `ofType` is a valid field.
+          LIST
+
+          # Indicates this type is a non-null. `ofType` is a valid field.
+          NON_NULL
+        }
+
+        # 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.
+        type __Field {
+          name: String!
+          description: String
+          args: [__InputValue!]!
+          type: __Type!
+          isDeprecated: Boolean!
+          deprecationReason: String
+        }
+
+        # 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.
+        type __InputValue {
+          name: String!
+          description: String
+          type: __Type!
+
+          # A GraphQL-formatted string representing the default value for this input value.
+          defaultValue: String
+        }
+
+        # 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.
+        type __EnumValue {
+          name: String!
+          description: String
+          isDeprecated: Boolean!
+          deprecationReason: String
+        }
+
+        type QueryType {
+          foo: Foo
+        }
+
+        type Foo implements Bar {
+          one: Type
+          two(argument: InputType!): Type
+          three(argument: InputType, other: String): Int
+          four(argument: String = "string"): String
+          five(argument: [String] = ["string", "string"]): String
+          six(argument: String): Type
+        }
+
+        interface Bar {
+          one: Type
+          four(argument: String = "string"): String
+        }
+
+        type Type {
+          a: String
+        }
+
+        input InputType {
+          key: String!
+          answer: Int = 42
+        }
+
+        # Represents non-fractional signed whole numeric values. Int can represent values between -(2^31) and 2^31 - 1.
+        scalar Int
+
+        type MutationType {
+          a(input: InputType): String
+        }
+
+        # 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.
+        type __Schema {
+          # A list of all types supported by this server.
+          types: [__Type!]!
+
+          # The type that query operations will be rooted at.
+          queryType: __Type!
+
+          # If this server supports mutation, the type that mutation operations will be rooted at.
+          mutationType: __Type
+
+          # If this server support subscription, the type that subscription operations will be rooted at.
+          subscriptionType: __Type
+
+          # A list of all directives supported by this server.
+          directives: [__Directive!]!
+        }
+
+        # A Directive provides a way to describe alternate runtime execution and type validation behavior in a GraphQL document.
+        #
+        # In some cases, you need to provide options to alter GraphQL's execution behavior
+        # in ways field arguments will not suffice, such as conditionally including or
+        # skipping a field. Directives provide this by describing additional information
+        # to the executor.
+        type __Directive {
+          name: String!
+          description: String
+          locations: [__DirectiveLocation!]!
+          args: [__InputValue!]!
+          onOperation: Boolean!
+          onFragment: Boolean!
+          onField: Boolean!
+        }
+
+        # A Directive can be adjacent to many parts of the GraphQL language, a
+        # __DirectiveLocation describes one such possible adjacencies.
+        enum __DirectiveLocation {
+          # Location adjacent to a query operation.
+          QUERY
+
+          # Location adjacent to a mutation operation.
+          MUTATION
+
+          # Location adjacent to a subscription operation.
+          SUBSCRIPTION
+
+          # Location adjacent to a field.
+          FIELD
+
+          # Location adjacent to a fragment definition.
+          FRAGMENT_DEFINITION
+
+          # Location adjacent to a fragment spread.
+          FRAGMENT_SPREAD
+
+          # Location adjacent to an inline fragment.
+          INLINE_FRAGMENT
+
+          # Location adjacent to a schema definition.
+          SCHEMA
+
+          # Location adjacent to a scalar definition.
+          SCALAR
+
+          # Location adjacent to an object type definition.
+          OBJECT
+
+          # Location adjacent to a field definition.
+          FIELD_DEFINITION
+
+          # Location adjacent to an argument definition.
+          ARGUMENT_DEFINITION
+
+          # Location adjacent to an interface definition.
+          INTERFACE
+
+          # Location adjacent to a union definition.
+          UNION
+
+          # Location adjacent to an enum definition.
+          ENUM
 
-    union Union = Type | QueryType
+          # Location adjacent to an enum value definition.
+          ENUM_VALUE
 
-    directive @skip(if: Boolean!) on FIELD | FRAGMENT_SPREAD | INLINE_FRAGMENT
+          # Location adjacent to an input object type definition.
+          INPUT_OBJECT
+
+          # Location adjacent to an input object field definition.
+          INPUT_FIELD_DEFINITION
+        }
+
+        # Represents signed double-precision fractional values as specified by [IEEE
+        # 754](http://en.wikipedia.org/wiki/IEEE_floating_point).
+        scalar Float
+
+        # Represents a unique identifier that is Base64 obfuscated. It is often used to
+        # refetch an object or as key for a cache. The ID type appears in a JSON response
+        # as a String; however, it is not intended to be human-readable. When expected as
+        # an input type, any string (such as `"VXNlci0xMA=="`) or integer (such as `4`)
+        # input value will be accepted as an ID.
+        scalar ID
 
-    directive @include(if: Boolean!) on FIELD | FRAGMENT_SPREAD | INLINE_FRAGMENT
+        # Scalar description
+        scalar CustomScalar
 
-    # Marks an element of a GraphQL schema as no longer supported.
-    directive @deprecated(reason: String = "No longer supported") on FIELD_DEFINITION | ENUM_VALUE
+        enum Site {
+          DESKTOP
+          MOBILE
+        }
 
-    schema {
-      query: QueryType
-      mutation: MutationType
-    }
-  GRAPHQL
-  }
+        union Union = Type | QueryType
 
-  let(:subject) { GraphQL::Language::DocumentFromSchemaDefinition }
+        directive @skip(if: Boolean!) on FIELD | FRAGMENT_SPREAD | INLINE_FRAGMENT
+
+        directive @include(if: Boolean!) on FIELD | FRAGMENT_SPREAD | INLINE_FRAGMENT
 
-  describe "#document" do
-    it "returns the document AST from the given schema" do
-      schema = GraphQL::Schema.from_definition(schema_idl)
-      document = subject.new(schema).document
+        # Marks an element of a GraphQL schema as no longer supported.
+        directive @deprecated(reason: String = "No longer supported") on FIELD_DEFINITION | ENUM_VALUE
+
+        schema {
+          query: QueryType
+          mutation: MutationType
+        }
+      GRAPHQL
+      }
 
-      expected_document = GraphQL.parse(expected_complete_idl)
+      let(:document) {
+        subject.new(
+          schema,
+          include_introspection_types: true,
+          include_built_in_directives: true,
+          include_built_in_scalars: true,
+          always_include_schema: true,
+        ).document
+      }
 
-      assert equivalent_node?(expected_document, document)
+      it "returns the full document AST from the given schema including built ins and introspection" do
+        assert equivalent_node?(expected_document, document)
+      end
     end
   end
 
@@ -321,12 +754,12 @@ describe GraphQL::Language::DocumentFromSchemaDefinition do
     return false unless expected.is_a?(node.class)
 
     if expected.respond_to?(:children) && expected.respond_to?(:scalars)
-      children_equal = node.children.all? do |child|
-        expected.children.find { |expected_child| equivalent_node?(expected_child, child) }
+      children_equal = expected.children.all? do |expected_child|
+        node.children.find { |child| equivalent_node?(expected_child, child) }
       end
 
-      scalars_equal = node.children.all? do |child|
-        expected.children.find { |expected_child| equivalent_node?(expected_child, child) }
+      scalars_equal = expected.children.all? do |expected_child|
+        node.children.find { |child| equivalent_node?(expected_child, child) }
       end
 
       children_equal && scalars_equal