graphql 1.7.14 → 1.8.0.pre1

data/lib/graphql/schema.rb

@@ -16,6 +16,17 @@ require "graphql/schema/validation"
 require "graphql/schema/warden"
 require "graphql/schema/build_from_definition"
 
+
+require "graphql/schema/member"
+require "graphql/schema/argument"
+require "graphql/schema/enum"
+require "graphql/schema/field"
+require "graphql/schema/input_object"
+require "graphql/schema/interface"
+require "graphql/schema/object"
+require "graphql/schema/scalar"
+require "graphql/schema/union"
+
 module GraphQL
   # A GraphQL schema which may be queried with {GraphQL::Query}.
   #
@@ -80,7 +91,6 @@ module GraphQL
       :orphan_types, :directives,
       :query_analyzers, :multiplex_analyzers, :instrumenters, :lazy_methods,
       :cursor_encoder,
-      :ast_node,
       :raise_definition_error
 
     # Single, long-lived instance of the provided subscriptions class, if there is one.
@@ -387,6 +397,18 @@ module GraphQL
     # @param ctx [GraphQL::Query::Context] The context for the current query
     # @return [GraphQL::ObjectType] The type for exposing `object` in GraphQL
     def resolve_type(type, object, ctx = :__undefined__)
+      check_resolved_type(type, object, ctx) do |ok_type, ok_object, ok_ctx|
+        if @resolve_type_proc.nil?
+          raise(NotImplementedError, "Can't determine GraphQL type for: #{ok_object.inspect}, define `resolve_type (type, obj, ctx) -> { ... }` inside `Schema.define`.")
+        end
+        @resolve_type_proc.call(ok_type, ok_object, ok_ctx)
+      end
+    end
+
+    # This is a compatibility hack so that instance-level and class-level
+    # methods can get correctness checks without calling one another
+    # @api private
+    def check_resolved_type(type, object, ctx = :__undefined__)
       if ctx == :__undefined__
         # Old method signature
         ctx = object
@@ -394,15 +416,20 @@ module GraphQL
         type = nil
       end
 
+      if object.is_a?(GraphQL::Schema::Object)
+        object = object.object
+      end
+
       # Prefer a type-local function; fall back to the schema-level function
       type_proc = type && type.resolve_type_proc
       type_result = if type_proc
         type_proc.call(object, ctx)
       else
-        if @resolve_type_proc.nil?
-          raise(NotImplementedError, "Can't determine GraphQL type for: #{object.inspect}, define `resolve_type (type, obj, ctx) -> { ... }` inside `Schema.define`.")
-        end
-        @resolve_type_proc.call(type, object, ctx)
+        yield(type, object, ctx)
+      end
+
+      if type_result.respond_to?(:graphql_definition)
+        type_result = type_result.graphql_definition
       end
 
       if type_result.nil?
@@ -543,19 +570,13 @@ module GraphQL
       GraphQL::Schema::Printer.print_schema(self, only: only, except: except, context: context)
     end
 
-    # Return the GraphQL::Language::Document IDL AST for the schema
-    # @return [GraphQL::Language::Document]
-    def to_document
-      GraphQL::Language::DocumentFromSchemaDefinition.new(self).document
-    end
-
     # Return the Hash response of {Introspection::INTROSPECTION_QUERY}.
     # @param context [Hash]
     # @param only [<#call(member, ctx)>]
     # @param except [<#call(member, ctx)>]
     # @return [Hash] GraphQL result
     def as_json(only: nil, except: nil, context: {})
-      execute(Introspection::INTROSPECTION_QUERY, only: only, except: except, context: context).to_h
+      execute(Introspection::INTROSPECTION_QUERY, only: only, except: except, context: context)
     end
 
     # Returns the JSON response of {Introspection::INTROSPECTION_QUERY}.
@@ -565,6 +586,191 @@ module GraphQL
       JSON.pretty_generate(as_json(*args))
     end
 
+    class << self
+      extend GraphQL::Delegate
+      def_delegators :graphql_definition, :as_json, :to_json
+
+      def method_missing(method_name, *args, &block)
+        if graphql_definition.respond_to?(method_name)
+          graphql_definition.public_send(method_name, *args, &block)
+        else
+          super
+        end
+      end
+
+      def respond_to_missing?(method_name, incl_private = false)
+        graphql_definition.respond_to?(method_name, incl_private) || super
+      end
+
+      def graphql_definition
+        @graphql_definition ||= to_graphql
+      end
+
+      def use(plugin, options = {})
+        plugins << [plugin, options]
+      end
+
+      def plugins
+        @plugins ||= []
+      end
+
+      def to_graphql
+        schema_defn = self.new
+        schema_defn.query = query
+        schema_defn.mutation = mutation
+        schema_defn.subscription = subscription
+        schema_defn.max_depth = max_depth
+        schema_defn.default_max_page_size = default_max_page_size
+        schema_defn.orphan_types = orphan_types
+        if !directives
+          directives(DIRECTIVES)
+        end
+        schema_defn.directives = directives
+        schema_defn.resolve_type = method(:resolve_type)
+        schema_defn.object_from_id = method(:object_from_id)
+        schema_defn.id_from_object = method(:id_from_object)
+        instrumenters.each do |step, insts|
+          insts.each do |inst|
+            schema_defn.instrumenters[step] << inst
+          end
+        end
+        schema_defn.instrumenters[:query] << GraphQL::Schema::Member::Instrumentation
+        lazy_classes.each do |lazy_class, value_method|
+          schema_defn.lazy_methods.set(lazy_class, value_method)
+        end
+        if plugins.any?
+          schema_plugins = plugins
+          # TODO don't depend on .define
+          schema_defn = schema_defn.redefine do
+            schema_plugins.each do |plugin, options|
+              if options.any?
+                use(plugin, **options)
+              else
+                use(plugin)
+              end
+            end
+          end
+        end
+        schema_defn.send(:rebuild_artifacts)
+
+        schema_defn
+      end
+
+      def query(new_query_object = nil)
+        if new_query_object
+          @query_object = new_query_object
+        else
+          @query_object.respond_to?(:graphql_definition) ? @query_object.graphql_definition : @query_object
+        end
+      end
+
+      def mutation(new_mutation_object = nil)
+        if new_mutation_object
+          @mutation_object = new_mutation_object
+        else
+          @mutation_object.respond_to?(:graphql_definition) ? @mutation_object.graphql_definition : @mutation_object
+        end
+      end
+
+      def subscription(new_subscription_object = nil)
+        if new_subscription_object
+          @subscription_object = new_subscription_object
+        else
+          @subscription_object.respond_to?(:graphql_definition) ? @subscription_object.graphql_definition : @subscription_object
+        end
+      end
+
+      def default_max_page_size(new_default_max_page_size = nil)
+        if new_default_max_page_size
+          @default_max_page_size = new_default_max_page_size
+        else
+          @default_max_page_size
+        end
+      end
+
+      def max_depth(new_max_depth = nil)
+        if new_max_depth
+          @max_depth = new_max_depth
+        else
+          @max_depth
+        end
+      end
+
+      def orphan_types(new_orphan_types = nil)
+        if new_orphan_types
+          @orphan_types = new_orphan_types
+        else
+          @orphan_types || []
+        end
+      end
+
+      def default_execution_strategy
+        if superclass <= GraphQL::Schema
+          superclass.default_execution_strategy
+        else
+          @default_execution_strategy
+        end
+      end
+
+      def resolve_type(type, obj, ctx)
+        raise NotImplementedError, "#{self.name}.resolve_type(type, obj, ctx) must be implemented to use Union types or Interface types (tried to resolve: #{type.name})"
+      end
+
+      def object_from_id(node_id, ctx)
+        raise NotImplementedError, "#{self.name}.object_from_id(node_id, ctx) must be implemented to use the `node` field (tried to load from id `#{node_id}`)"
+      end
+
+      def id_from_object(object, type, ctx)
+        raise NotImplementedError, "#{self.name}.id_from_object(object, type, ctx) must be implemented to create global ids (tried to create an id for `#{object.inspect}`)"
+      end
+
+      def lazy_resolve(lazy_class, value_method)
+        lazy_classes[lazy_class] = value_method
+      end
+
+      def instrument(instrument_step, instrumenter, options = {})
+        step = if instrument_step == :field && options[:after_built_ins]
+          :field_after_built_ins
+        else
+          instrument_step
+        end
+        instrumenters[step] << instrumenter
+      end
+
+      def directives(new_directives = nil)
+        if new_directives
+          @directives = new_directives.reduce({}) { |m, d| m[d.name] = d; m }
+        end
+        @directives
+      end
+
+      private
+
+      def lazy_classes
+        @lazy_classes ||= {}
+      end
+
+      def instrumenters
+        @instrumenters ||= Hash.new { |h,k| h[k] = [] }
+      end
+    end
+
+
+    def self.inherited(child_class)
+      child_class.singleton_class.class_eval do
+        prepend(MethodWrappers)
+      end
+    end
+
+    module MethodWrappers
+      # Wrap the user-provided resolve-type in a correctness check
+      def resolve_type(type, obj, ctx = :__undefined__)
+        graphql_definition.check_resolved_type(type, obj, ctx) do |ok_type, ok_obj, ok_ctx|
+          super(ok_type, ok_obj, ok_ctx)
+        end
+      end
+    end
+
     protected
 
     def rescues?
@@ -585,6 +791,7 @@ module GraphQL
       GraphQL::Relay::ConnectionInstrumentation,
       GraphQL::Relay::EdgesInstrumentation,
       GraphQL::Relay::Mutation::Instrumentation,
+      GraphQL::Schema::Member::Instrumentation,
     ]
 
     def rebuild_artifacts

data/lib/graphql/schema/argument.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+module GraphQL
+  class Schema
+    class Argument
+      include GraphQL::Schema::Member::CachedGraphQLDefinition
+
+      NO_DEFAULT = :__no_default__
+
+      attr_reader :name
+
+      def initialize(arg_name, type_expr, desc = nil, required:, default_value: NO_DEFAULT)
+        @name = arg_name.to_s
+        @type_expr = type_expr
+        @description = desc
+        @null = !required
+        @default_value = default_value
+      end
+
+      def to_graphql
+        argument = GraphQL::Argument.new
+        argument.name = @name
+        argument.type = -> {
+          Member::BuildType.parse_type(@type_expr, null: @null)
+        }
+        argument.description = @description
+        if NO_DEFAULT != @default_value
+          argument.default_value = @default_value
+        end
+        argument
+      end
+    end
+  end
+end

data/lib/graphql/schema/build_from_definition.rb

@@ -107,8 +107,6 @@ module GraphQL
             directives directives.values
           end
 
-          schema.ast_node = schema_definition if schema_definition
-
           schema
         end
 
@@ -119,26 +117,18 @@ module GraphQL
         NullScalarCoerce = ->(val, _ctx) { val }
 
         def build_enum_type(enum_type_definition, type_resolver)
-          enum = GraphQL::EnumType.define(
+          GraphQL::EnumType.define(
             name: enum_type_definition.name,
             description: enum_type_definition.description,
             values: enum_type_definition.values.map do |enum_value_definition|
-              value = EnumType::EnumValue.define(
+              EnumType::EnumValue.define(
                 name: enum_value_definition.name,
                 value: enum_value_definition.name,
                 deprecation_reason: build_deprecation_reason(enum_value_definition.directives),
                 description: enum_value_definition.description,
               )
-
-              value.ast_node = enum_value_definition
-
-              value
             end
           )
-
-          enum.ast_node = enum_type_definition
-
-          enum
         end
 
         def build_deprecation_reason(directives)
@@ -158,8 +148,6 @@ module GraphQL
             coerce: NullScalarCoerce,
           )
 
-          scalar_type.ast_node = scalar_type_definition
-
           if default_resolve.respond_to?(:coerce_input)
             scalar_type = scalar_type.redefine(
               coerce_input: ->(val, ctx) { default_resolve.coerce_input(scalar_type, val, ctx) },
@@ -171,15 +159,11 @@ module GraphQL
         end
 
         def build_union_type(union_type_definition, type_resolver)
-          union = GraphQL::UnionType.define(
+          GraphQL::UnionType.define(
             name: union_type_definition.name,
             description: union_type_definition.description,
             possible_types: union_type_definition.types.map{ |type_name| type_resolver.call(type_name) },
           )
-
-          union.ast_node = union_type_definition
-
-          union
         end
 
         def build_object_type(object_type_definition, type_resolver, default_resolve:)
@@ -191,20 +175,14 @@ module GraphQL
             fields: Hash[build_fields(object_type_definition.fields, type_resolver, default_resolve: typed_resolve_fn)],
             interfaces: object_type_definition.interfaces.map{ |interface_name| type_resolver.call(interface_name) },
           )
-          type_def.ast_node = object_type_definition
-          type_def
         end
 
         def build_input_object_type(input_object_type_definition, type_resolver)
-          input = GraphQL::InputObjectType.define(
+          GraphQL::InputObjectType.define(
             name: input_object_type_definition.name,
             description: input_object_type_definition.description,
             arguments: Hash[build_input_arguments(input_object_type_definition, type_resolver)],
           )
-
-          input.ast_node = input_object_type_definition
-
-          input
         end
 
         def build_default_value(default_value)
@@ -213,10 +191,6 @@ module GraphQL
             default_value.name
           when GraphQL::Language::Nodes::NullValue
             nil
-          when GraphQL::Language::Nodes::InputObject
-            default_value.to_h
-          when Array
-            default_value.map { |v| build_default_value(v) }
           else
             default_value
           end
@@ -230,33 +204,25 @@ module GraphQL
               kwargs[:default_value] = build_default_value(input_argument.default_value)
             end
 
-            argument = GraphQL::Argument.define(
-              name: input_argument.name,
-              type: type_resolver.call(input_argument.type),
-              description: input_argument.description,
-              **kwargs,
-            )
-
-            argument.ast_node = input_object_type_definition
-
             [
               input_argument.name,
-              argument
+              GraphQL::Argument.define(
+                name: input_argument.name,
+                type: type_resolver.call(input_argument.type),
+                description: input_argument.description,
+                **kwargs,
+              )
             ]
           end
         end
 
         def build_directive(directive_definition, type_resolver)
-          directive = GraphQL::Directive.define(
+          GraphQL::Directive.define(
             name: directive_definition.name,
             description: directive_definition.description,
             arguments: Hash[build_directive_arguments(directive_definition, type_resolver)],
             locations: directive_definition.locations.map(&:to_sym),
           )
-
-          directive.ast_node = directive_definition
-
-          directive
         end
 
         def build_directive_arguments(directive_definition, type_resolver)
@@ -267,32 +233,24 @@ module GraphQL
               kwargs[:default_value] = build_default_value(directive_argument.default_value)
             end
 
-            argument = GraphQL::Argument.define(
-              name: directive_argument.name,
-              type: type_resolver.call(directive_argument.type),
-              description: directive_argument.description,
-              **kwargs,
-            )
-
-            argument.ast_node = directive_argument
-
             [
               directive_argument.name,
-              argument
+              GraphQL::Argument.define(
+                name: directive_argument.name,
+                type: type_resolver.call(directive_argument.type),
+                description: directive_argument.description,
+                **kwargs,
+              )
             ]
           end
         end
 
         def build_interface_type(interface_type_definition, type_resolver)
-          interface = GraphQL::InterfaceType.define(
+          GraphQL::InterfaceType.define(
             name: interface_type_definition.name,
             description: interface_type_definition.description,
             fields: Hash[build_fields(interface_type_definition.fields, type_resolver, default_resolve: nil)],
           )
-
-          interface.ast_node = interface_type_definition
-
-          interface
         end
 
         def build_fields(field_definitions, type_resolver, default_resolve:)
@@ -311,8 +269,6 @@ module GraphQL
                 **kwargs,
               )
 
-              arg.ast_node = argument
-
               [argument.name, arg]
             end]
 
@@ -325,8 +281,6 @@ module GraphQL
               deprecation_reason: build_deprecation_reason(field_definition.directives),
             )
 
-            field.ast_node = field_definition
-
             type_name = resolve_type_name(field_definition.type)
             field.connection = type_name.end_with?("Connection")
             [field_definition.name, field]