feat(Schema) accept optional directives in definition

Author: rmosolgo

lib/graphql/execution/deferred_execution.rb

@@ -329,14 +329,12 @@ def resolve_field_frame(scope, thread, frame, field_defn)
         # Build arguments according to query-string literals, default values, and query variables
         arguments = query.arguments_for(frame.node, field_defn)
 
+        query.context.ast_node = ast_node
+        query.context.irep_node = frame.node
+
         # This is the last call in the middleware chain; it actually calls the user's resolve proc
         field_resolve_middleware_proc = -> (_parent_type, parent_object, field_definition, field_args, query_ctx, _next) {
-          query_ctx.ast_node = ast_node
-          query_ctx.irep_node = frame.node
-          value = field_definition.resolve(parent_object, field_args, query_ctx)
-          query_ctx.ast_node = nil
-          query_ctx.irep_node = frame.node
-          value
+          field_definition.resolve(parent_object, field_args, query_ctx)
         }
 
         # Send arguments through the middleware stack,
@@ -353,6 +351,9 @@ def resolve_field_frame(scope, thread, frame, field_defn)
           resolve_fn_value = err
         end
 
+        query.context.ast_node = nil
+        query.context.irep_node = nil
+
         case resolve_fn_value
         when GraphQL::ExecutionError
           thread.errors << resolve_fn_value

lib/graphql/schema.rb

@@ -46,6 +46,7 @@ class Schema
     include GraphQL::Define::InstanceDefinable
     accepts_definitions \
       :query, :mutation, :subscription,
+      :directives,
       :query_execution_strategy, :mutation_execution_strategy, :subscription_execution_strategy,
       :max_depth, :max_complexity,
       :orphan_types, :resolve_type,
@@ -61,14 +62,17 @@ class Schema
       :orphan_types,
       :query_analyzers, :middleware
 
-    DIRECTIVES = [
+    BUILT_IN_DIRECTIVES = [
       GraphQL::Directive::IncludeDirective,
       GraphQL::Directive::SkipDirective,
       GraphQL::Directive::DeprecatedDirective,
-      GraphQL::Directive::DeferDirective,
-      GraphQL::Directive::StreamDirective,
     ]
 
+    OPTIONAL_DIRECTIVES = {
+      "@defer" => GraphQL::Directive::DeferDirective,
+      "@stream" => GraphQL::Directive::StreamDirective,
+    }
+
     DYNAMIC_FIELDS = ["__type", "__typename", "__schema"]
 
     attr_reader :directives, :static_validator, :object_from_id_proc, :id_from_object_proc, :resolve_type_proc
@@ -83,7 +87,7 @@ class Schema
     # @param types [Array<GraphQL::BaseType>] additional types to include in this schema
     def initialize
       @orphan_types = []
-      @directives = DIRECTIVES.reduce({}) { |m, d| m[d.name] = d; m }
+      @directives = BUILT_IN_DIRECTIVES.reduce({}) { |m, d| m[d.name] = d; m }
       @static_validator = GraphQL::StaticValidation::Validator.new(schema: self)
       @middleware = []
       @query_analyzers = []
@@ -96,6 +100,15 @@ def initialize
       @subscription_execution_strategy = GraphQL::Query::SerialExecution
     end
 
+    def directives=(directive_names)
+      ensure_defined
+      directive_names.each do |name|
+        dir = OPTIONAL_DIRECTIVES.fetch(name)
+        @directives[dir.name] = dir
+      end
+      @directives
+    end
+
     def rescue_from(*args, &block)
       ensure_defined
       rescue_middleware.rescue_from(*args, &block)

spec/graphql/execution/deferred_execution_spec.rb

@@ -334,7 +334,7 @@ def merged_result
             }
           end
         end
-        schema = GraphQL::Schema.define(query: query_type)
+        schema = GraphQL::Schema.define(query: query_type, directives: ["@stream", "@defer"])
         schema.query_execution_strategy = GraphQL::Execution::DeferredExecution
         schema
       }

spec/graphql/schema/printer_spec.rb

@@ -154,12 +154,6 @@
   reason: String = "No longer supported"
 ) on FIELD_DEFINITION | ENUM_VALUE
 
-# Push this part of the query in a later patch
-directive @defer on FIELD | FRAGMENT_SPREAD | INLINE_FRAGMENT
-
-# Push items from this list in sequential patches
-directive @stream on FIELD
-
 # A Directive provides a way to describe alternate runtime execution and type validation behavior in a GraphQL document.
 #
 # In some cases, you need to provide options to alter GraphQL's execution behavior

spec/graphql/schema_spec.rb

@@ -124,4 +124,40 @@
       end
     end
   end
+
+  describe "#directives" do
+    let(:schema) {
+      query_type = GraphQL::ObjectType.define do
+        name "Query"
+        field :one, types.Int, resolve: -> (o,a,c) { 1 }
+      end
+
+      schema_directives = directives
+
+      GraphQL::Schema.define do
+        query(query_type)
+        directives(schema_directives)
+      end
+    }
+
+    describe "when @defer is not provided" do
+      let(:directives) { [] }
+      it "doesn't execute queries with defer" do
+        res = schema.execute("{ one @defer }")
+        assert_equal nil, res["data"]
+        assert_equal 1, res["errors"].length
+      end
+    end
+
+    describe "when @defer is provided" do
+      let(:directives) { ["@defer"] }
+
+      it "executes queries with defer" do
+        res = schema.execute("{ one @defer, two: one }")
+        # The deferred field is left out ??
+        assert_equal({ "two" => 1 }, res["data"])
+        assert_equal nil, res["errors"]
+      end
+    end
+  end
 end

spec/support/dairy_app.rb

@@ -356,6 +356,8 @@ def self.create(type:, data:)
 
   rescue_from(NoSuchDairyError) { |err| err.message  }
 
+  directives ["@defer", "@stream"]
+
   resolve_type ->(obj, ctx) {
     DummySchema.types[obj.class.name]
   }