graphql 1.7.7 → 1.7.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 38483eef219e223ada69c9b3abf6be4b21b18631
-  data.tar.gz: 6e7b06898fbc81c29dd817ee9817ae54e4a44ada
+  metadata.gz: d85dab3949103799bd681457cdb2fecd6ddcaddf
+  data.tar.gz: ed5808c8a3caba6bf7834c0c7e2299ad5597eab3
 SHA512:
-  metadata.gz: 8c1813ee4f6758846e9f5620d1952517c9d7a3d714e265d18da05fcd68425f152afdae56f8c400fd55d4e455e03443f26d90e04fd69578d85c71b3130f5eaf0f
-  data.tar.gz: 41480a626d5acf9db70ea864438e192bab03ec56ad89c137f9f5e63e9ada426c3fd812b9099e8f4c621e3705740fd7daf1d1f74019c632ebd19f54e62608eb90
+  metadata.gz: 19330668600890f1dd17e4231e5ded4a43b4cf35dc3c076b07a0b8d54449924c1967c8c9609c4ea9729beaf800c9d63280d48ce7ccefb18b0466db8b54494108
+  data.tar.gz: 80a05ac7f10d5c2a3727d12f4ca8f30cfa3634d8047e1d23cc15f66e1c63940c9d27e0d7d875e05d084897702d56794daf314c830785edae969d8fab0ab06399

data/lib/graphql/enum_type.rb

@@ -121,7 +121,7 @@ module GraphQL
       if enum_value
         enum_value.name
       else
-        raise(UnresolvedValueError, "Can't resolve enum #{name} for #{value}")
+        raise(UnresolvedValueError, "Can't resolve enum #{name} for #{value.inspect}")
       end
     end
 

data/lib/graphql/field.rb

@@ -131,6 +131,7 @@ module GraphQL
       :relay_nodes_field,
       :subscription_scope,
       :trace,
+      :introspection,
       argument: GraphQL::Define::AssignArgument
 
     ensure_defined(
@@ -138,7 +139,8 @@ module GraphQL
       :mutation, :arguments, :complexity, :function,
       :resolve, :resolve=, :lazy_resolve, :lazy_resolve=, :lazy_resolve_proc, :resolve_proc,
       :type, :type=, :name=, :property=, :hash_key=,
-      :relay_node_field, :relay_nodes_field, :edges?, :edge_class, :subscription_scope
+      :relay_node_field, :relay_nodes_field, :edges?, :edge_class, :subscription_scope,
+      :introspection?
     )
 
     # @return [Boolean] True if this is the Relay find-by-id field
@@ -183,6 +185,7 @@ module GraphQL
     attr_accessor :arguments_class
 
     attr_writer :connection
+    attr_writer :introspection
 
     # @return [nil, String] Prefix for subscription names from this field
     attr_accessor :subscription_scope
@@ -217,6 +220,7 @@ module GraphQL
       @connection_max_page_size = nil
       @edge_class = nil
       @trace = nil
+      @introspection = false
     end
 
     def initialize_copy(other)
@@ -224,6 +228,11 @@ module GraphQL
       @arguments = other.arguments.dup
     end
 
+    # @return [Boolean] Is this field a predefined introspection field?
+    def introspection?
+      @introspection
+    end
+
     # Get a value for this field
     # @example resolving a field value
     #   field.resolve(obj, args, ctx)

data/lib/graphql/input_object_type.rb

@@ -84,6 +84,7 @@ module GraphQL
 
     def coerce_non_null_input(value, ctx)
       input_values = {}
+      defaults_used = Set.new
 
       arguments.each do |input_key, input_field_defn|
         field_value = value[input_key]
@@ -93,10 +94,11 @@ module GraphQL
           input_values[input_key] = input_field_defn.prepare(coerced_value, ctx)
         elsif input_field_defn.default_value?
           input_values[input_key] = input_field_defn.default_value
+          defaults_used << input_key
         end
       end
 
-      arguments_class.new(input_values)
+      arguments_class.new(input_values, defaults_used)
     end
 
     # @api private

data/lib/graphql/introspection/arguments_field.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 GraphQL::Introspection::ArgumentsField = GraphQL::Field.define do
   type !GraphQL::ListType.new(of_type: !GraphQL::Introspection::InputValueType)
+  introspection true
   resolve ->(obj, args, ctx) {
     ctx.warden.arguments(obj)
   }

data/lib/graphql/introspection/enum_values_field.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 GraphQL::Introspection::EnumValuesField = GraphQL::Field.define do
   type types[!GraphQL::Introspection::EnumValueType]
+  introspection true
   argument :includeDeprecated, types.Boolean, default_value: false
   resolve ->(object, arguments, context) do
     if !object.kind.enum?

data/lib/graphql/introspection/fields_field.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 GraphQL::Introspection::FieldsField = GraphQL::Field.define do
   type -> { types[!GraphQL::Introspection::FieldType] }
+  introspection true
   argument :includeDeprecated, GraphQL::BOOLEAN_TYPE, default_value: false
   resolve ->(object, arguments, context) {
     return nil if !object.kind.fields?

data/lib/graphql/introspection/input_fields_field.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 GraphQL::Introspection::InputFieldsField = GraphQL::Field.define do
   name "inputFields"
+  introspection true
   type types[!GraphQL::Introspection::InputValueType]
   resolve ->(target, a, ctx) {
     if target.kind.input_object?

data/lib/graphql/introspection/interfaces_field.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 GraphQL::Introspection::InterfacesField = GraphQL::Field.define do
   type -> { types[!GraphQL::Introspection::TypeType] }
+  introspection true
   resolve ->(target, a, ctx) {
     if target.kind == GraphQL::TypeKinds::OBJECT
       ctx.warden.interfaces(target)

data/lib/graphql/introspection/of_type_field.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 GraphQL::Introspection::OfTypeField = GraphQL::Field.define do
   name "ofType"
+  introspection true
   type -> { GraphQL::Introspection::TypeType }
   resolve ->(obj, args, ctx) { obj.kind.wraps? ? obj.of_type : nil }
 end

data/lib/graphql/introspection/possible_types_field.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 GraphQL::Introspection::PossibleTypesField = GraphQL::Field.define do
   type -> { types[!GraphQL::Introspection::TypeType] }
+  introspection true
   resolve ->(target, args, ctx) {
     if target.kind.resolves?
       ctx.warden.possible_types(target)

data/lib/graphql/introspection/schema_field.rb

@@ -4,6 +4,7 @@ module GraphQL
     SchemaField = GraphQL::Field.define do
       name("__schema")
       description("This GraphQL schema")
+      introspection true
       type(!GraphQL::Introspection::SchemaType)
       resolve ->(o, a, ctx) { ctx.query.schema }
     end

data/lib/graphql/introspection/type_by_name_field.rb

@@ -5,6 +5,7 @@ module GraphQL
       name("__type")
       description("A type in the GraphQL system")
       type(GraphQL::Introspection::TypeType)
+      introspection true
       argument :name, !types.String
       resolve ->(o, args, ctx) {
         ctx.warden.get_type(args["name"])

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