graphql 1.7.7 → 1.7.8

data/lib/graphql/object_type.rb

@@ -32,7 +32,7 @@ module GraphQL
     #   @return [Hash<String => GraphQL::Field>] Map String fieldnames to their {GraphQL::Field} implementations
 
     # @!attribute mutation
-    #   @return [GraphQL::Relay::Mutation, nil] The mutation this field was derived from, if it was derived from a mutation
+    #   @return [GraphQL::Relay::Mutation, nil] The mutation this object type was derived from, if it is an auto-generated payload type.
 
     def initialize
       super

data/lib/graphql/query/arguments.rb

@@ -12,8 +12,8 @@ module GraphQL
         argument_owner.arguments_class = Class.new(self) do
           self.argument_definitions = argument_definitions
 
-          def initialize(values)
-            super(values, argument_definitions: self.class.argument_definitions)
+          def initialize(values, defaults_used)
+            super(values, argument_definitions: self.class.argument_definitions, defaults_used: defaults_used)
           end
 
           argument_definitions.each do |_arg_name, arg_definition|
@@ -36,13 +36,16 @@ module GraphQL
         end
       end
 
-      def initialize(values, argument_definitions:)
+      def initialize(values, argument_definitions:, defaults_used:)
         @argument_values = values.inject({}) do |memo, (inner_key, inner_value)|
-          arg_defn = argument_definitions[inner_key.to_s]
+          arg_name = inner_key.to_s
+
+          arg_defn = argument_definitions[arg_name]
+          arg_default_used = defaults_used.include?(arg_name)
 
           arg_value = wrap_value(inner_value, arg_defn.type)
           string_key = arg_defn.expose_as
-          memo[string_key] = ArgumentValue.new(string_key, arg_value, arg_defn)
+          memo[string_key] = ArgumentValue.new(string_key, arg_value, arg_defn, arg_default_used)
           memo
         end
       end
@@ -61,6 +64,13 @@ module GraphQL
         @argument_values.key?(key_s)
       end
 
+      # @param key [String, Symbol] name of value to access
+      # @return [Boolean] true if the argument default was passed as the argument value to the resolver
+      def default_used?(key)
+        key_s = key.is_a?(String) ? key : key.to_s
+        @argument_values.fetch(key_s, NULL_ARGUMENT_VALUE).default_used?
+      end
+
       # Get the hash of all values, with stringified keys
       # @return [Hash] the stringified hash
       def to_h
@@ -85,7 +95,7 @@ module GraphQL
         end
       end
 
-      NO_ARGS = self.new({}, argument_definitions: [])
+      NO_ARGS = self.new({}, argument_definitions: [], defaults_used: Set.new)
 
       class << self
         attr_accessor :argument_definitions
@@ -95,14 +105,22 @@ module GraphQL
 
       class ArgumentValue
         attr_reader :key, :value, :definition
-        def initialize(key, value, definition)
+        attr_writer :default_used
+
+        def initialize(key, value, definition, default_used)
           @key = key
           @value = value
           @definition = definition
+          @default_used = default_used
+        end
+
+        # @return [Boolean] true if the argument default was passed as the argument value to the resolver
+        def default_used?
+          @default_used
         end
       end
 
-      NULL_ARGUMENT_VALUE = ArgumentValue.new(nil, nil, nil)
+      NULL_ARGUMENT_VALUE = ArgumentValue.new(nil, nil, nil, nil)
 
       def wrap_value(value, arg_defn_type)
         if value.nil?
@@ -115,7 +133,7 @@ module GraphQL
             wrap_value(value, arg_defn_type.of_type)
           when GraphQL::InputObjectType
             if value.is_a?(Hash)
-              arg_defn_type.arguments_class.new(value)
+              arg_defn_type.arguments_class.new(value, Set.new)
             else
               value
             end

data/lib/graphql/query/literal_input.rb

@@ -49,6 +49,8 @@ module GraphQL
       def self.from_arguments(ast_arguments, argument_owner, variables)
         context = variables ? variables.context : nil
         values_hash = {}
+        defaults_used = Set.new
+
         indexed_arguments = case ast_arguments
         when Hash
           ast_arguments
@@ -93,6 +95,7 @@ module GraphQL
           # then add the default value.
           if arg_defn.default_value? && !values_hash.key?(arg_name)
             value = arg_defn.default_value
+            defaults_used << arg_name
             # `context` isn't present when pre-calculating defaults
             if context
               value = arg_defn.prepare(value, context)
@@ -105,7 +108,7 @@ module GraphQL
           end
         end
 
-        argument_owner.arguments_class.new(values_hash)
+        argument_owner.arguments_class.new(values_hash, defaults_used)
       end
     end
   end

data/lib/graphql/schema/printer.rb

@@ -36,7 +36,7 @@ module GraphQL
     #   printer = GraphQL::Schema::Printer.new(MySchema)
     #   puts printer.print_type(post_type)
     #
-    class Printer
+    class Printer < GraphQL::Language::Printer
       attr_reader :schema, :warden
 
       # @param schema [GraphQL::Schema]
@@ -45,21 +45,32 @@ module GraphQL
       # @param except [<#call(member, ctx)>]
       # @param introspection [Boolean] Should include the introspection types in the string?
       def initialize(schema, context: nil, only: nil, except: nil, introspection: false)
-        @schema = schema
-        @context = context
+        @document_from_schema = GraphQL::Language::DocumentFromSchemaDefinition.new(
+          schema,
+          context: context,
+          only: only,
+          except: except,
+          include_introspection_types: introspection,
+        )
+
+        @document = @document_from_schema.document
 
-        blacklist = build_blacklist(only, except, introspection: introspection)
-        filter = GraphQL::Filter.new(except: blacklist)
-        @warden = GraphQL::Schema::Warden.new(filter, schema: @schema, context: @context)
+        @schema = schema
       end
 
       # Return the GraphQL schema string for the introspection type system
       def self.print_introspection_schema
         query_root = ObjectType.define(name: "Root")
         schema = GraphQL::Schema.define(query: query_root)
-        blacklist = ->(m, ctx) { m == query_root }
-        printer = new(schema, except: blacklist, introspection: true)
-        printer.print_schema
+
+        introspection_schema_ast = GraphQL::Language::DocumentFromSchemaDefinition.new(
+          schema,
+          except: ->(member, _) { member.name == "Root" },
+          include_introspection_types: true,
+          include_built_in_directives: true,
+        ).document
+
+        introspection_schema_ast.to_query_string(printer: IntrospectionPrinter.new)
       end
 
       # Return a GraphQL schema string for the defined types in the schema
@@ -74,277 +85,33 @@ module GraphQL
 
       # Return a GraphQL schema string for the defined types in the schema
       def print_schema
-        directive_definitions = warden.directives.map { |directive| print_directive(directive) }
-
-        printable_types = warden.types.reject(&:default_scalar?)
-
-        type_definitions = printable_types
-          .sort_by(&:name)
-          .map { |type| print_type(type) }
-
-        [print_schema_definition].compact
-                                 .concat(directive_definitions)
-                                 .concat(type_definitions).join("\n\n")
+        print(@document)
       end
 
       def print_type(type)
-        TypeKindPrinters::STRATEGIES.fetch(type.kind).print(warden, type)
+        node = @document_from_schema.build_object_type_node(type)
+        print(node)
       end
 
-      private
-
-      # By default, these are included in a schema printout
-      IS_USER_DEFINED_MEMBER = ->(member) {
-        case member
-        when GraphQL::BaseType
-          !member.introspection?
-        when GraphQL::Directive
-          !member.default_directive?
-        else
-          true
-        end
-      }
-
-      private_constant :IS_USER_DEFINED_MEMBER
+      def print_directive(directive)
+        if directive.name == "deprecated"
+          reason = directive.arguments.find { |arg| arg.name == "reason" }
 
-      def build_blacklist(only, except, introspection:)
-        if introspection
-          if only
-            ->(m, ctx) { !only.call(m, ctx) }
-          elsif except
-            except
+          if reason.value == GraphQL::Directive::DEFAULT_DEPRECATION_REASON
+            "@deprecated"
           else
-            ->(m, ctx) { false }
+            "@deprecated(reason: \"#{reason.value}\")"
           end
         else
-          if only
-            ->(m, ctx) { !(IS_USER_DEFINED_MEMBER.call(m) && only.call(m, ctx)) }
-          elsif except
-            ->(m, ctx) { !IS_USER_DEFINED_MEMBER.call(m) || except.call(m, ctx) }
-          else
-            ->(m, ctx) { !IS_USER_DEFINED_MEMBER.call(m) }
-          end
+          super
         end
       end
 
-      def print_schema_definition
-        if (schema.query.nil? || schema.query.name == 'Query') &&
-           (schema.mutation.nil? || schema.mutation.name == 'Mutation') &&
-           (schema.subscription.nil? || schema.subscription.name == 'Subscription')
-          return
+      class IntrospectionPrinter < GraphQL::Language::Printer
+        def print_schema_definition(schema)
+          "schema {\n  query: Root\n}"
         end
-
-        operations = [:query, :mutation, :subscription].map do |operation_type|
-          object_type = schema.public_send(operation_type)
-          # Special treatment for the introspection schema, which prints `{ query: "Root" }`
-          if object_type && (warden.get_type(object_type.name) || (object_type.name == "Root" && schema.query == object_type))
-            "  #{operation_type}: #{object_type.name}\n"
-          else
-            nil
-          end
-        end.compact.join
-        "schema {\n#{operations}}"
-      end
-
-      def print_directive(directive)
-        TypeKindPrinters::DirectivePrinter.print(warden, directive)
-      end
-
-      module TypeKindPrinters
-        module DeprecatedPrinter
-          def print_deprecated(field_or_enum_value)
-            return unless field_or_enum_value.deprecation_reason
-
-            case field_or_enum_value.deprecation_reason
-            when nil
-              ''
-            when '', GraphQL::Directive::DEFAULT_DEPRECATION_REASON
-              ' @deprecated'
-            else
-              " @deprecated(reason: #{field_or_enum_value.deprecation_reason.to_s.inspect})"
-            end
-          end
-        end
-
-        module DescriptionPrinter
-          def print_description(definition, indentation='', first_in_block=true)
-            return '' unless definition.description
-
-            description = indentation != '' && !first_in_block ? "\n".dup : "".dup
-            description << GraphQL::Language::Comments.commentize(definition.description, indent: indentation)
-          end
-        end
-
-        module ArgsPrinter
-          include DescriptionPrinter
-          def print_args(warden, field, indentation = '')
-            arguments = warden.arguments(field)
-            return if arguments.empty?
-
-            if arguments.all?{ |arg| !arg.description }
-              return "(#{arguments.map{ |arg| print_input_value(arg) }.join(", ")})"
-            end
-
-            out = "(\n".dup
-            out << arguments.sort_by(&:name).map.with_index{ |arg, i|
-              "#{print_description(arg, "  #{indentation}", i == 0)}  #{indentation}"\
-              "#{print_input_value(arg)}"
-            }.join("\n")
-            out << "\n#{indentation})"
-          end
-
-          def print_input_value(arg)
-            if arg.default_value?
-              default_string = " = #{print_value(arg.default_value, arg.type)}"
-            else
-              default_string = nil
-            end
-
-            "#{arg.name}: #{arg.type.to_s}#{default_string}"
-          end
-
-          def print_value(value, type)
-            case type
-            when FLOAT_TYPE
-              return 'null' if value.nil?
-              value.to_f.inspect
-            when INT_TYPE
-              return 'null' if value.nil?
-              value.to_i.inspect
-            when BOOLEAN_TYPE
-              return 'null' if value.nil?
-              (!!value).inspect
-            when ScalarType, ID_TYPE, STRING_TYPE
-              return 'null' if value.nil?
-              value.to_s.inspect
-            when EnumType
-              return 'null' if value.nil?
-              type.coerce_isolated_result(value)
-            when InputObjectType
-              return 'null' if value.nil?
-              fields = value.to_h.map{ |field_name, field_value|
-                field_type = type.input_fields.fetch(field_name.to_s).type
-                "#{field_name}: #{print_value(field_value, field_type)}"
-              }.join(", ")
-              "{#{fields}}"
-            when NonNullType
-              print_value(value, type.of_type)
-            when ListType
-              return 'null' if value.nil?
-              "[#{value.to_a.map{ |v| print_value(v, type.of_type) }.join(", ")}]"
-            else
-              raise NotImplementedError, "Unexpected value type #{type.inspect}"
-            end
-          end
-        end
-
-        module FieldPrinter
-          include DeprecatedPrinter
-          include ArgsPrinter
-          include DescriptionPrinter
-          def print_fields(warden, type)
-            fields = warden.fields(type)
-            fields.sort_by(&:name).map.with_index { |field, i|
-              "#{print_description(field, '  ', i == 0)}"\
-              "  #{field.name}#{print_args(warden, field, '  ')}: #{field.type}#{print_deprecated(field)}"
-            }.join("\n")
-          end
-        end
-
-        class DirectivePrinter
-          extend ArgsPrinter
-          extend DescriptionPrinter
-          def self.print(warden, directive)
-            "#{print_description(directive)}"\
-            "directive @#{directive.name}#{print_args(warden, directive)} "\
-            "on #{directive.locations.join(' | ')}"
-          end
-        end
-
-        class ScalarPrinter
-          extend DescriptionPrinter
-          def self.print(warden, type)
-            "#{print_description(type)}"\
-            "scalar #{type.name}"
-          end
-        end
-
-        class ObjectPrinter
-          extend FieldPrinter
-          extend DescriptionPrinter
-          def self.print(warden, type)
-            interfaces = warden.interfaces(type)
-            if interfaces.any?
-              implementations = " implements #{interfaces.sort_by(&:name).map(&:to_s).join(", ")}"
-            else
-              implementations = nil
-            end
-
-            "#{print_description(type)}"\
-            "type #{type.name}#{implementations} {\n"\
-            "#{print_fields(warden, type)}\n"\
-            "}"
-          end
-        end
-
-        class InterfacePrinter
-          extend FieldPrinter
-          extend DescriptionPrinter
-          def self.print(warden, type)
-            "#{print_description(type)}"\
-            "interface #{type.name} {\n#{print_fields(warden, type)}\n}"
-          end
-        end
-
-        class UnionPrinter
-          extend DescriptionPrinter
-          def self.print(warden, type)
-            possible_types = warden.possible_types(type)
-            "#{print_description(type)}"\
-            "union #{type.name} = #{possible_types.sort_by(&:name).map(&:to_s).join(" | ")}"
-          end
-        end
-
-        class EnumPrinter
-          extend DeprecatedPrinter
-          extend DescriptionPrinter
-          def self.print(warden, type)
-            enum_values = warden.enum_values(type)
-
-            values = enum_values.sort_by(&:name).map.with_index { |v, i|
-              "#{print_description(v, '  ', i == 0)}"\
-              "  #{v.name}#{print_deprecated(v)}"
-            }.join("\n")
-
-            "#{print_description(type)}"\
-            "enum #{type.name} {\n#{values}\n}"
-          end
-        end
-
-        class InputObjectPrinter
-          extend FieldPrinter
-          extend DescriptionPrinter
-          def self.print(warden, type)
-            arguments = warden.arguments(type)
-            fields = arguments.sort_by(&:name).map.with_index{ |field, i|
-              "#{print_description(field, "  ", i == 0)}"\
-              "  #{print_input_value(field)}"
-            }.join("\n")
-            "#{print_description(type)}"\
-            "input #{type.name} {\n#{fields}\n}"
-          end
-        end
-
-        STRATEGIES = {
-          GraphQL::TypeKinds::SCALAR =>       ScalarPrinter,
-          GraphQL::TypeKinds::OBJECT =>       ObjectPrinter,
-          GraphQL::TypeKinds::INTERFACE =>    InterfacePrinter,
-          GraphQL::TypeKinds::UNION =>        UnionPrinter,
-          GraphQL::TypeKinds::ENUM =>         EnumPrinter,
-          GraphQL::TypeKinds::INPUT_OBJECT => InputObjectPrinter,
-        }
       end
-      private_constant :TypeKindPrinters
     end
   end
 end