graphql 1.7.6 → 1.8.0

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.to_s.inspect})"
           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

data/lib/graphql/schema/relay_classic_mutation.rb

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+module GraphQL
+  class Schema
+    # Mutations that extend this base class get some conventions added for free:
+    #
+    # - An argument called `clientMutationId` is _always_ added, but it's not passed
+    #   to the resolve method. The value is re-inserted to the response. (It's for
+    #   client libraries to manage optimistic updates.)
+    # - The returned object type always has a field called `clientMutationId` to support that.
+    # - The mutation accepts one argument called `input`, `argument`s defined in the mutation
+    #   class are added to that input object, which is generated by the mutation.
+    #
+    # These conventions were first specified by Relay Classic, but they come in handy:
+    #
+    # - `clientMutationId` supports optimistic updates and cache rollbacks on the client
+    # - using a single `input:` argument makes it easy to post whole JSON objects to the mutation
+    #   using one GraphQL variable (`$input`) instead of making a separate variable for each argument.
+    #
+    # @see {GraphQL::Schema::Mutation} for an example, it's basically the same.
+    #
+    class RelayClassicMutation < GraphQL::Schema::Mutation
+      # The payload should always include this field
+      field(:client_mutation_id, String, "A unique identifier for the client performing the mutation.", null: true)
+      # Relay classic default:
+      null(true)
+
+      # Override {GraphQL::Schema::Mutation#resolve_mutation} to
+      # delete `client_mutation_id` from the kwargs.
+      def resolve_mutation(kwargs)
+        # This is handled by Relay::Mutation::Resolve, a bit hacky, but here we are.
+        kwargs.delete(:client_mutation_id)
+        resolve(**kwargs)
+      end
+
+      resolve_method(:resolve_mutation)
+
+      class << self
+        # The base class for generated input object types
+        # @param new_class [Class] The base class to use for generating input object definitions
+        # @return [Class] The base class for this mutation's generated input object (default is {GraphQL::Schema::InputObject})
+        def input_object_class(new_class = nil)
+          if new_class
+            @input_object_class = new_class
+          end
+          @input_object_class || (superclass.respond_to?(:input_object_class) ? superclass.input_object_class : GraphQL::Schema::InputObject)
+        end
+
+        # @param new_input_type [Class, nil] If provided, it configures this mutation to accept `new_input_type` instead of generating an input type
+        # @return [Class] The generated {Schema::InputObject} class for this mutation's `input`
+        def input_type(new_input_type = nil)
+          if new_input_type
+            @input_type = new_input_type
+          end
+          @input_type ||= generate_input_type
+        end
+
+        # Extend {Schema::Mutation.field_options} to add the `input` argument
+        def field_options
+          sig = super
+          # Arguments were added at the root, but they should be nested
+          sig[:arguments].clear
+          sig[:arguments][:input] = { type: input_type, required: true }
+          sig
+        end
+
+        private
+
+        # Generate the input type for the `input:` argument
+        # To customize how input objects are generated, override this method
+        # @return [Class] a subclass of {.input_object_class}
+        def generate_input_type
+          mutation_args = arguments
+          mutation_name = graphql_name
+          mutation_class = self
+          Class.new(input_object_class) do
+            graphql_name("#{mutation_name}Input")
+            description("Autogenerated input type of #{mutation_name}")
+            mutation(mutation_class)
+            own_arguments.merge!(mutation_args)
+            argument :client_mutation_id, String, "A unique identifier for the client performing the mutation.", required: false
+          end
+        end
+      end
+    end
+  end
+end

data/lib/graphql/schema/rescue_middleware.rb

@@ -41,13 +41,14 @@ module GraphQL
       private
 
       def attempt_rescue(err)
-        handler = rescue_table[err.class]
-        if handler
-          message = handler.call(err)
-          GraphQL::ExecutionError.new(message)
-        else
-          raise(err)
-        end
+        rescue_table.each { |klass, handler|
+          if klass.is_a?(Class) && err.is_a?(klass) && handler
+            message = handler.call(err)
+            return GraphQL::ExecutionError.new(message)
+          end
+        }
+
+        raise(err)
       end
     end
   end

data/lib/graphql/schema/resolver.rb

@@ -0,0 +1,122 @@
+# frozen_string_literal: true
+
+module GraphQL
+  class Schema
+    # A class-based container for field configuration and resolution logic. It supports:
+    #
+    # - Arguments, via `.argument(...)` helper, which will be applied to the field.
+    # - Return type, via `.type(..., null: ...)`, which will be applied to the field.
+    # - Description, via `.description(...)`, which will be applied to the field
+    # - Resolution, via `#resolve(**args)` method, which will be called to resolve the field.
+    # - `#object` and `#context` accessors for use during `#resolve`.
+    #
+    # Resolvers can be attached with the `resolver:` option in a `field(...)` call.
+    #
+    # A resolver's configuration may be overridden with other keywords in the `field(...)` call.
+    #
+    # See the {.field_options} to see how a Resolver becomes a set of field configuration options.
+    #
+    # @see {GraphQL::Schema::Mutation} for a concrete subclass of `Resolver`.
+    # @see {GraphQL::Function} `Resolver` is a replacement for `GraphQL::Function`
+    class Resolver
+      include Schema::Member::GraphQLTypeNames
+      # Really we only need description from here, but:
+      extend Schema::Member::BaseDSLMethods
+      extend GraphQL::Schema::Member::HasArguments
+
+      # @param object [Object] the initialize object, pass to {Query.initialize} as `root_value`
+      # @param context [GraphQL::Query::Context]
+      def initialize(object:, context:)
+        @object = object
+        @context = context
+      end
+
+      # @return [Object] The application object this field is being resolved on
+      attr_reader :object
+
+      # @return [GraphQL::Query::Context]
+      attr_reader :context
+
+      # Do the work. Everything happens here.
+      # @return [Object] An object corresponding to the return type
+      def resolve(**args)
+        raise NotImplementedError, "#{self.class.name}#resolve should execute the field's logic"
+      end
+
+      class << self
+        # Default `:resolve` set below.
+        # @return [Symbol] The method to call on instances of this object to resolve the field
+        def resolve_method(new_method = nil)
+          if new_method
+            @resolve_method = new_method
+          end
+          @resolve_method || (superclass.respond_to?(:resolve_method) ? superclass.resolve_method : :resolve)
+        end
+
+        # Additional info injected into {#resolve}
+        # @see {GraphQL::Schema::Field#extras}
+        def extras(new_extras = nil)
+          if new_extras
+            @own_extras = new_extras
+          end
+          own_extras = @own_extras || []
+          own_extras + (superclass.respond_to?(:extras) ? superclass.extras : [])
+        end
+
+        # Specifies whether or not the field is nullable. Defaults to `true`
+        # TODO unify with {#type}
+        # @param allow_null [Boolean] Whether or not the response can be null
+        def null(allow_null = nil)
+          if !allow_null.nil?
+            @null = allow_null
+          end
+
+          @null.nil? ? (superclass.respond_to?(:null) ? superclass.null : true) : @null
+        end
+
+        # Call this method to get the return type of the field,
+        # or use it as a configuration method to assign a return type
+        # instead of generating one.
+        # TODO unify with {#null}
+        # @param new_type [Class, nil] If a type definition class is provided, it will be used as the return type of the field
+        # @param null [true, false] Whether or not the field may return `nil`
+        # @return [Class] The type which this field returns.
+        def type(new_type = nil, null: nil)
+          if new_type
+            if null.nil?
+              raise ArgumentError, "required argument `null:` is missing"
+            end
+            @type_expr = new_type
+            @null = null
+          else
+            if @type_expr
+              GraphQL::Schema::Member::BuildType.parse_type(@type_expr, null: @null)
+            elsif superclass.respond_to?(:type)
+              superclass.type
+            else
+              nil
+            end
+          end
+        end
+
+        def field_options
+          {
+            type: type_expr,
+            description: description,
+            extras: extras,
+            method: resolve_method,
+            resolver_class: self,
+            arguments: arguments,
+            null: null,
+          }
+        end
+
+        # A non-normalized type configuration, without `null` applied
+        # @api private
+        def type_expr
+          @type_expr || (superclass.respond_to?(:type_expr) ? superclass.type_expr : nil)
+        end
+      end
+    end
+  end
+end

data/lib/graphql/schema/scalar.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+module GraphQL
+  class Schema
+    class Scalar < GraphQL::Schema::Member
+      extend GraphQL::Schema::Member::AcceptsDefinition
+
+      class << self
+        extend Forwardable
+        def_delegators :graphql_definition, :coerce_isolated_input, :coerce_isolated_result
+
+        def coerce_input(val, ctx)
+          val
+        end
+
+        def coerce_result(val, ctx)
+          val
+        end
+
+        def to_graphql
+          type_defn = GraphQL::ScalarType.new
+          type_defn.name = graphql_name
+          type_defn.description = description
+          type_defn.coerce_result = method(:coerce_result)
+          type_defn.coerce_input = method(:coerce_input)
+          type_defn.metadata[:type_class] = self
+          type_defn
+        end
+
+        def kind
+          GraphQL::TypeKinds::SCALAR
+        end
+      end
+    end
+  end
+end