graphql 1.8.0.pre2 → 1.8.0.pre3

data/lib/graphql/schema/input_object.rb

@@ -4,8 +4,8 @@ module GraphQL
     class InputObject < GraphQL::Schema::Member
       extend GraphQL::Delegate
 
-      def initialize(values, context:)
-        @arguments = self.class.arguments_class.new(values, context: context)
+      def initialize(values, context:, defaults_used:)
+        @arguments = self.class.arguments_class.new(values, context: context, defaults_used: defaults_used)
         @context = context
       end
 

data/lib/graphql/schema/introspection_system.rb

@@ -0,0 +1,93 @@
+# frozen_string_literal: true
+module GraphQL
+  class Schema
+    class IntrospectionSystem
+      attr_reader :schema_type, :type_type, :typename_field
+
+      def initialize(schema)
+        @schema = schema
+        @built_in_namespace = GraphQL::Introspection
+        @custom_namespace = schema.introspection_namespace || @built_in_namespace
+
+        # Use to-graphql to avoid sharing with any previous instantiations
+        @schema_type = load_constant(:SchemaType).to_graphql
+        @type_type = load_constant(:TypeType).to_graphql
+        @field_type = load_constant(:FieldType).to_graphql
+        @directive_type = load_constant(:DirectiveType).to_graphql
+        @enum_value_type = load_constant(:EnumValueType).to_graphql
+        @input_value_type = load_constant(:InputValueType).to_graphql
+        @type_kind_enum = load_constant(:TypeKindEnum).to_graphql
+        @directive_location_enum = load_constant(:DirectiveLocationEnum).to_graphql
+        @entry_point_fields = get_fields_from_class(class_sym: :EntryPoints)
+        @dynamic_fields = get_fields_from_class(class_sym: :DynamicFields)
+      end
+
+      def object_types
+        [
+          @schema_type,
+          @type_type,
+          @field_type,
+          @directive_type,
+          @enum_value_type,
+          @input_value_type,
+          @type_kind_enum,
+          @directive_location_enum,
+        ]
+      end
+
+      def entry_points
+        @entry_point_fields.values
+      end
+
+      def entry_point(name:)
+        @entry_point_fields[name]
+      end
+
+      def dynamic_fields
+        @dynamic_fields.values
+      end
+
+      def dynamic_field(name:)
+        @dynamic_fields[name]
+      end
+
+      private
+
+      def load_constant(class_name)
+        @custom_namespace.const_get(class_name)
+      rescue NameError
+        # Dup the built-in so that the cached fields aren't shared
+        @built_in_namespace.const_get(class_name)
+      end
+
+      def get_fields_from_class(class_sym:)
+        object_class = load_constant(class_sym)
+        object_type_defn = object_class.to_graphql
+        extracted_field_defns = {}
+        object_type_defn.all_fields.each do |field_defn|
+          inner_resolve = field_defn.resolve_proc
+          resolve_with_instantiate = PerFieldProxyResolve.new(object_class: object_class, inner_resolve: inner_resolve)
+          extracted_field_defns[field_defn.name] = field_defn.redefine(resolve: resolve_with_instantiate)
+        end
+        extracted_field_defns
+      end
+
+      class PerFieldProxyResolve
+        def initialize(object_class:, inner_resolve:)
+          @object_class = object_class
+          @inner_resolve = inner_resolve
+        end
+
+        def call(obj, args, ctx)
+          query_ctx = ctx.query.context
+          # Remove the QueryType wrapper
+          if obj.is_a?(GraphQL::Schema::Object)
+            obj = obj.object
+          end
+          wrapped_object = @object_class.new(obj, query_ctx)
+          @inner_resolve.call(wrapped_object, args, ctx)
+        end
+      end
+    end
+  end
+end

data/lib/graphql/schema/late_bound_type.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+module GraphQL
+  class Schema
+    # A stand-in for a type which will be resolved in a given schema, by name.
+    # TODO: support argument types too, make this a public API somehow
+    # @api Private
+    class LateBoundType
+      attr_reader :name
+      def initialize(local_name)
+        @name = local_name
+      end
+
+      def unwrap
+        self
+      end
+
+      def to_non_null_type
+        GraphQL::NonNullType.new(of_type: self)
+      end
+
+      def to_list_type
+        GraphQL::ListType.new(of_type: self)
+      end
+
+      def inspect
+        "#<LateBoundType @name=#{name}>"
+      end
+
+      alias :to_s :inspect
+    end
+  end
+end

data/lib/graphql/schema/member.rb

@@ -15,6 +15,11 @@ module GraphQL
         def graphql_definition
           @graphql_definition ||= to_graphql
         end
+
+        def initialize_copy(original)
+          super
+          @graphql_definition = nil
+        end
       end
 
       # These constants are interpreted as GraphQL types
@@ -58,7 +63,7 @@ module GraphQL
           if new_name
             @graphql_name = new_name
           else
-            @graphql_name || self.name.split("::").last.sub(/Type\Z/, "")
+            overridden_graphql_name || self.name.split("::").last.sub(/Type\Z/, "")
           end
         end
 
@@ -84,6 +89,15 @@ module GraphQL
           end
         end
 
+        # @return [Boolean] If true, this object is part of the introspection system
+        def introspection(new_introspection = nil)
+          if !new_introspection.nil?
+            @introspection = new_introspection
+          else
+            @introspection || (superclass <= Schema::Member ? superclass.introspection : false)
+          end
+        end
+
         def to_graphql
           raise NotImplementedError
         end
@@ -95,6 +109,12 @@ module GraphQL
         def to_non_null_type
           NonNullTypeProxy.new(self)
         end
+
+        protected
+
+        def overridden_graphql_name
+          @graphql_name || (superclass <= GraphQL::Schema::Member ? superclass.overridden_graphql_name : nil)
+        end
       end
     end
   end

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

@@ -43,7 +43,7 @@ module GraphQL
                 end
               end
             end
-          when GraphQL::BaseType
+          when GraphQL::BaseType, GraphQL::Schema::LateBoundType
             type_expr
           when Array
             if type_expr.length != 1
@@ -77,7 +77,7 @@ module GraphQL
 
         def to_type_name(something)
           case something
-          when GraphQL::BaseType
+          when GraphQL::BaseType, GraphQL::Schema::LateBoundType
             something.unwrap.name
           when Array
             to_type_name(something.first)
@@ -95,11 +95,13 @@ module GraphQL
         end
 
         def camelize(string)
-          return string unless string.include?('_')
-
-          string.split('_').map(&:capitalize).join.tap do |camelized|
-            camelized[0] = camelized[0].downcase
+          return string unless string.include?("_")
+          camelized = string.split('_').map(&:capitalize).join
+          camelized[0] = camelized[0].downcase
+          if string.start_with?("__")
+            camelized = "__#{camelized}"
           end
+          camelized
         end
 
         def underscore(string)

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

@@ -30,7 +30,7 @@ module GraphQL
         # @param field_defn [GraphQL::Schema::Field]
         # @return [void]
         def add_field(field_defn)
-          fields.reject! {|f| f.name == field_defn.name}
+          own_fields.reject! {|f| f.name == field_defn.name}
           own_fields << field_defn
           nil
         end

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

@@ -100,7 +100,9 @@ module GraphQL
               end
 
               if concrete_type && (object_class = concrete_type.metadata[:object_class])
-                object_class.new(obj, ctx)
+                # use the query-level context here, since it won't be field-specific anyways
+                query_ctx = ctx.query.context
+                object_class.new(obj, query_ctx)
               else
                 obj
               end

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

@@ -15,6 +15,10 @@ module GraphQL
         def to_graphql
           @member.graphql_definition.to_list_type
         end
+
+        def to_non_null_type
+          NonNullTypeProxy.new(self)
+        end
       end
     end
   end

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

@@ -15,6 +15,10 @@ module GraphQL
         def to_graphql
           @member.graphql_definition.to_non_null_type
         end
+
+        def to_list_type
+          ListTypeProxy.new(self)
+        end
       end
     end
   end

data/lib/graphql/schema/object.rb

@@ -45,9 +45,10 @@ module GraphQL
           obj_type.name = graphql_name
           obj_type.description = description
           obj_type.interfaces = interfaces
+          obj_type.introspection = introspection
 
           fields.each do |field_inst|
-            field_defn = field_inst.graphql_definition
+            field_defn = field_inst.to_graphql
             obj_type.fields[field_defn.name] = field_defn
           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