graphql 1.7.14 → 1.8.0.pre1

data/lib/graphql/schema/member/build_type.rb

@@ -0,0 +1,106 @@
+# frozen_string_literal: true
+module GraphQL
+  class Schema
+    class Member
+      # @api private
+      module BuildType
+        module_function
+        # @param type_expr [String, Class, GraphQL::BaseType]
+        # @return [GraphQL::BaseType]
+        def parse_type(type_expr, null:)
+          list_type = false
+
+          return_type = case type_expr
+          when String
+            case type_expr
+            when "String"
+              GraphQL::STRING_TYPE
+            when "Int", "Integer"
+              GraphQL::INT_TYPE
+            when "Float"
+              GraphQL::FLOAT_TYPE
+            when "Boolean"
+              GraphQL::BOOLEAN_TYPE
+            when "ID"
+              GraphQL::ID_TYPE
+            when /\A\[.*\]\Z/
+              list_type = true
+              # List members are required by default
+              parse_type(type_expr[1..-2], null: false)
+            when /.*!\Z/
+              null = false
+              parse_type(type_expr[0..-2], null: true)
+            else
+              maybe_type = Object.const_get(type_expr)
+              case maybe_type
+              when GraphQL::BaseType
+                maybe_type
+              when Class
+                if maybe_type < GraphQL::Schema::Member
+                  maybe_type.graphql_definition
+                else
+                  raise "Unexpected class found for GraphQL type: #{type_expr} (must be GraphQL::Object)"
+                end
+              end
+            end
+          when GraphQL::BaseType
+            type_expr
+          when Array
+            if type_expr.length != 1
+              raise "Use an array of length = 1 for list types; other arrays are not supported"
+            end
+            list_type = true
+            # List members are required by default
+            parse_type(type_expr.first, null: false)
+          when Class
+            if Class < GraphQL::Schema::Member
+              type_expr.graphql_definition
+            else
+              # Eg `String` => GraphQL::STRING_TYPE
+              parse_type(type_expr.name, null: true)
+            end
+          end
+
+          # Apply list_type first, that way the
+          # .to_non_null_type applies to the list type, not the inner type
+          if list_type
+            return_type = return_type.to_list_type
+          end
+
+          if !null
+            return_type = return_type.to_non_null_type
+          end
+
+
+          return_type
+        end
+
+        def to_type_name(something)
+          case something
+          when GraphQL::BaseType
+            something.unwrap.name
+          when Array
+            to_type_name(something.first)
+          when Module
+            if something < GraphQL::Schema::Member
+              something.graphql_name
+            else
+              something.name.split("::").last
+            end
+          when String
+            something.gsub(/\]\[\!/, "").split("::").last
+          else
+            raise "Unhandled to_type_name input: #{something} (#{something.class})"
+          end
+        end
+
+        def underscore(string)
+          string
+            .gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2') # URLDecoder -> URL_Decoder
+            .gsub(/([a-z\d])([A-Z])/,'\1_\2')     # someThing -> some_Thing
+            .downcase
+        end
+      end
+    end
+  end
+end

data/lib/graphql/schema/member/has_fields.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+module GraphQL
+  class Schema
+    class Member
+      # Shared code for Object and Interface
+      module HasFields
+        # Add a field to this object or interface with the given definition
+        # @see {GraphQL::Schema::Field#initialize} for method signature
+        # @return [void]
+        def field(*args, &block)
+          field_defn = field_class.new(*args, &block)
+          add_field(field_defn)
+          nil
+        end
+
+        # @return [Array<GraphQL::Schema::Field>] Fields on this object, including inherited fields
+        def fields
+          all_fields = own_fields
+          inherited_fields = (superclass.is_a?(HasFields) ? superclass.fields : [])
+          # Remove any inherited fields which were overridden on this class:
+          inherited_fields.each do |inherited_f|
+            if all_fields.none? {|f| f.name == inherited_f.name}
+              all_fields << inherited_f
+            end
+          end
+          all_fields
+        end
+
+        # Register this field with the class, overriding a previous one if needed
+        # @param field_defn [GraphQL::Schema::Field]
+        # @return [void]
+        def add_field(field_defn)
+          fields.reject! {|f| f.name == field_defn.name}
+          own_fields << field_defn
+          nil
+        end
+
+        # @return [Class] The class to initialize when adding fields to this kind of schema member
+        def field_class(new_field_class = nil)
+          if new_field_class
+            @field_class = new_field_class
+          else
+            @field_class || superclass.field_class
+          end
+        end
+
+        private
+
+        # @return [Array<GraphQL::Schema::Field>] Fields defined on this class _specifically_, not parent classes
+        def own_fields
+          @own_fields ||= []
+        end
+      end
+    end
+  end
+end

data/lib/graphql/schema/member/instrumentation.rb

@@ -0,0 +1,113 @@
+# frozen_string_literal: true
+# test_via: ../object.rb
+
+module GraphQL
+  class Schema
+    class Member
+      module Instrumentation
+        module_function
+        def instrument(type, field)
+          return_type = field.type.unwrap
+          if return_type.metadata[:object_class] ||
+              return_type.is_a?(GraphQL::InterfaceType) ||
+              (return_type.is_a?(GraphQL::UnionType) && return_type.possible_types.any? { |t| t.metadata[:object_class] })
+            field = apply_proxy(field)
+          end
+
+          field
+        end
+
+        def before_query(query)
+          # Get the root type for this query
+          root_node = query.irep_selection
+          if root_node.nil?
+            # It's an invalid query, nothing to do here
+          else
+            root_type = query.irep_selection.return_type
+            # If it has a wrapper, apply it
+            wrapper_class = root_type.metadata[:object_class]
+            if wrapper_class
+              new_root_value = wrapper_class.new(query.root_value, query.context)
+              query.root_value = new_root_value
+            end
+          end
+        end
+
+        def after_query(_query)
+        end
+
+        private
+
+        module_function
+
+        def apply_proxy(field)
+          resolve_proc = field.resolve_proc
+          lazy_resolve_proc = field.lazy_resolve_proc
+          inner_return_type = field.type.unwrap
+          depth = list_depth(field.type)
+
+          field.redefine(
+            resolve: ProxiedResolve.new(inner_resolve: resolve_proc, list_depth: depth, inner_return_type: inner_return_type),
+            lazy_resolve: ProxiedResolve.new(inner_resolve: lazy_resolve_proc, list_depth: depth, inner_return_type: inner_return_type),
+          )
+        end
+
+        def list_depth(type, starting_at = 0)
+          case type
+          when GraphQL::ListType
+            list_depth(type.of_type, starting_at + 1)
+          when GraphQL::NonNullType
+            list_depth(type.of_type, starting_at)
+          else
+            starting_at
+          end
+        end
+
+        class ProxiedResolve
+          def initialize(inner_resolve:, list_depth:, inner_return_type:)
+            @inner_resolve = inner_resolve
+            @inner_return_type = inner_return_type
+            @list_depth = list_depth
+          end
+
+          def call(obj, args, ctx)
+            result = @inner_resolve.call(obj, args, ctx)
+            if ctx.schema.lazy?(result)
+              # Wrap it later
+              result
+            elsif ctx.skip == result
+              result
+            else
+              proxy_to_depth(result, @list_depth, @inner_return_type, ctx)
+            end
+          end
+
+          private
+
+          def proxy_to_depth(obj, depth, type, ctx)
+            if depth > 0
+              obj.map { |inner_obj| proxy_to_depth(inner_obj, depth - 1, type, ctx) }
+            elsif obj.nil?
+              obj
+            else
+              concrete_type = case type
+              when GraphQL::UnionType, GraphQL::InterfaceType
+                ctx.query.resolve_type(type, obj)
+              when GraphQL::ObjectType
+                type
+              else
+                raise "unexpected proxying type #{type} for #{obj} at #{ctx.owner_type}.#{ctx.field.name}"
+              end
+
+              if concrete_type && (object_class = concrete_type.metadata[:object_class])
+                object_class.new(obj, ctx)
+              else
+                obj
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/graphql/schema/member/list_type_proxy.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+module GraphQL
+  class Schema
+    class Member
+      # Wraps a {Schema::Member} as a list type.
+      # @see {Schema::Member#to_list_type}
+      # @api private
+      class ListTypeProxy
+        include GraphQL::Schema::Member::CachedGraphQLDefinition
+
+        def initialize(member)
+          @member = member
+        end
+
+        def to_graphql
+          @member.graphql_definition.to_list_type
+        end
+      end
+    end
+  end
+end

data/lib/graphql/schema/member/non_null_type_proxy.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+module GraphQL
+  class Schema
+    class Member
+      # Wraps a {Schema::Member} when it is required.
+      # @see {Schema::Member#to_non_null_type}
+      # @api private
+      class NonNullTypeProxy
+        include GraphQL::Schema::Member::CachedGraphQLDefinition
+
+        def initialize(member)
+          @member = member
+        end
+
+        def to_graphql
+          @member.graphql_definition.to_non_null_type
+        end
+      end
+    end
+  end
+end

data/lib/graphql/schema/object.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+module GraphQL
+  class Schema
+    class Object < GraphQL::Schema::Member
+      attr_reader :object
+
+      def initialize(object, context)
+        @object = object
+        @context = context
+      end
+      extend GraphQL::Schema::Member::HasFields
+      field_class GraphQL::Schema::Field
+
+      class << self
+        def implements(*new_interfaces)
+          new_interfaces.each do |int|
+            if int.is_a?(Class) && int < GraphQL::Schema::Interface
+              # Add the graphql field defns
+              int.fields.each do |field|
+                add_field(field)
+              end
+              # And call the implemented hook
+              int.apply_implemented(self)
+            else
+              int.all_fields.each do |f|
+                field(f.name, field: f)
+              end
+            end
+          end
+          own_interfaces.concat(new_interfaces)
+        end
+
+        def interfaces
+          own_interfaces + (superclass <= GraphQL::Schema::Object ? superclass.interfaces : [])
+        end
+
+        def own_interfaces
+          @own_interfaces ||= []
+        end
+
+        # @return [GraphQL::ObjectType]
+        def to_graphql
+          obj_type = GraphQL::ObjectType.new
+          obj_type.name = graphql_name
+          obj_type.description = description
+          obj_type.interfaces = interfaces
+
+          fields.each do |field_inst|
+            field_defn = field_inst.graphql_definition
+            obj_type.fields[field_defn.name] = field_defn
+          end
+
+          obj_type.metadata[:object_class] = self
+
+          obj_type
+        end
+
+        def global_id_field(field_name)
+          field field_name, "ID", null: false, resolve: GraphQL::Relay::GlobalIdResolve.new(type: self)
+        end
+      end
+    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 < GraphQL::Language::Printer
+    class Printer
       attr_reader :schema, :warden
 
       # @param schema [GraphQL::Schema]
@@ -45,32 +45,21 @@ 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)
-        @document_from_schema = GraphQL::Language::DocumentFromSchemaDefinition.new(
-          schema,
-          context: context,
-          only: only,
-          except: except,
-          include_introspection_types: introspection,
-        )
-
-        @document = @document_from_schema.document
-
         @schema = schema
+        @context = context
+
+        blacklist = build_blacklist(only, except, introspection: introspection)
+        filter = GraphQL::Filter.new(except: blacklist)
+        @warden = GraphQL::Schema::Warden.new(filter, schema: @schema, context: @context)
       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)
-
-        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)
+        blacklist = ->(m, ctx) { m == query_root }
+        printer = new(schema, except: blacklist, introspection: true)
+        printer.print_schema
       end
 
       # Return a GraphQL schema string for the defined types in the schema
@@ -85,33 +74,277 @@ module GraphQL
 
       # Return a GraphQL schema string for the defined types in the schema
       def print_schema
-        print(@document)
+        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")
       end
 
       def print_type(type)
-        node = @document_from_schema.build_object_type_node(type)
-        print(node)
+        TypeKindPrinters::STRATEGIES.fetch(type.kind).print(warden, type)
       end
 
-      def print_directive(directive)
-        if directive.name == "deprecated"
-          reason = directive.arguments.find { |arg| arg.name == "reason" }
+      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
 
-          if reason.value == GraphQL::Directive::DEFAULT_DEPRECATION_REASON
-            "@deprecated"
+      def build_blacklist(only, except, introspection:)
+        if introspection
+          if only
+            ->(m, ctx) { !only.call(m, ctx) }
+          elsif except
+            except
           else
-            "@deprecated(reason: #{reason.value.to_s.inspect})"
+            ->(m, ctx) { false }
           end
         else
-          super
+          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
         end
       end
 
-      class IntrospectionPrinter < GraphQL::Language::Printer
-        def print_schema_definition(schema)
-          "schema {\n  query: Root\n}"
+      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
         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