graphql 1.8.0.pre11 → 1.8.0

data/lib/graphql/schema/non_null.rb

@@ -29,6 +29,10 @@ module GraphQL
       def kind
         GraphQL::TypeKinds::NON_NULL
       end
+
+      def unwrap
+        @of_type.unwrap
+      end
     end
   end
 end

data/lib/graphql/schema/object.rb

@@ -45,7 +45,7 @@ module GraphQL
             if int.is_a?(GraphQL::InterfaceType)
               int_f = {}
               int.fields.each do |name, legacy_field|
-                int_f[name] = build_field(name, field: legacy_field)
+                int_f[name] = field_class.from_options(name, field: legacy_field)
               end
               all_fields = int_f.merge(all_fields)
             end

data/lib/graphql/schema/relay_classic_mutation.rb

@@ -22,22 +22,20 @@ module GraphQL
     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)
-        super
+        resolve(**kwargs)
       end
 
-      class << self
-        def inherited(base)
-          base.null(true)
-          super
-        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})
@@ -57,16 +55,17 @@ module GraphQL
           @input_type ||= generate_input_type
         end
 
-        private
-
-        # Extend {Schema::Mutation.generate_field} to add the `input` argument
-        def generate_field
-          field_instance = super
-          field_instance.own_arguments.clear
-          field_instance.argument(:input, input_type, required: true)
-          field_instance
+        # 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}

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/subscriptions/instrumentation.rb

@@ -56,7 +56,11 @@ module GraphQL
             ctx.skip
           elsif ctx.irep_node.subscription_topic == ctx.query.subscription_topic
             # The root object is _already_ the subscription update:
-            obj
+            if obj.is_a?(GraphQL::Schema::Object)
+              obj.object
+            else
+              obj
+            end
           else
             # This is a subscription update, but this event wasn't triggered.
             ctx.skip

data/lib/graphql/subscriptions/serialize.rb

@@ -35,6 +35,8 @@ module GraphQL
           obj.map { |i| dump_recursive(i) }.join(':')
         when obj.is_a?(Hash)
           obj.map { |k, v| "#{dump_recursive(k)}:#{dump_recursive(v)}" }.join(":")
+        when obj.is_a?(GraphQL::Schema::InputObject)
+          dump_recursive(obj.to_h)
         when obj.respond_to?(:to_gid_param)
           obj.to_gid_param
         when obj.respond_to?(:to_param)

data/lib/graphql/tracing/new_relic_tracing.rb

@@ -14,7 +14,33 @@ module GraphQL
         "execute_query_lazy" => "GraphQL/execute",
       }
 
+      # @param set_transaction_name [Boolean] If true, the GraphQL operation name will be used as the transaction name.
+      #   This is not advised if you run more than one query per HTTP request, for example, with `graphql-client` or multiplexing.
+      #   It can also be specified per-query with `context[:set_new_relic_transaction_name]`.
+      def initialize(set_transaction_name: false)
+        @set_transaction_name = set_transaction_name
+        super
+      end
+
       def platform_trace(platform_key, key, data)
+        if key == "execute_query"
+          set_this_txn_name =  data[:query].context[:set_new_relic_transaction_name]
+          if set_this_txn_name == true || (set_this_txn_name.nil? && @set_transaction_name)
+            query = data[:query]
+            # Set the transaction name based on the operation type and name
+            selected_op = query.selected_operation
+            if selected_op
+              op_type = selected_op.operation_type
+              op_name = selected_op.name || "anonymous"
+            else
+              op_type = "query"
+              op_name = "anonymous"
+            end
+
+            NewRelic::Agent.set_transaction_name("GraphQL/#{op_type}.#{op_name}")
+          end
+        end
+
         NewRelic::Agent::MethodTracerHelpers.trace_execution_scoped(platform_key) do
           yield
         end

data/lib/graphql/version.rb

@@ -1,4 +1,4 @@
 # frozen_string_literal: true
 module GraphQL
-  VERSION = "1.8.0.pre11"
+  VERSION = "1.8.0"
 end

data/readme.md

@@ -37,7 +37,7 @@ Or, see ["Getting Started"](https://rmosolgo.github.io/graphql-ruby/).
 
 ## Upgrade
 
-I also sell [GraphQL::Pro](http://graphql.pro) which provides several features on top of the GraphQL runtime, including [authorization](http://rmosolgo.github.io/graphql-ruby/pro/authorization), [monitoring](http://rmosolgo.github.io/graphql-ruby/pro/monitoring) plugins and [persisted queries](http://rmosolgo.github.io/graphql-ruby/operation_store/overview). Besides that, Pro customers get email support and an opportunity to support graphql-ruby's development!
+I also sell [GraphQL::Pro](http://graphql.pro) which provides several features on top of the GraphQL runtime, including [authorization](http://rmosolgo.github.io/graphql-ruby/pro/authorization), [Pusher-based subscriptions](http://graphql-ruby.org/subscriptions/pusher_implementation) and [persisted queries](http://rmosolgo.github.io/graphql-ruby/operation_store/overview). Besides that, Pro customers get email support and an opportunity to support graphql-ruby's development!
 
 ## Goals
 

data/spec/generators/graphql/install_generator_spec.rb

@@ -192,7 +192,7 @@ DummySchema = GraphQL::Schema.define do
   }
 
   # Object Resolution
-  resolve_type -> (obj, ctx) {
+  resolve_type -> (type, obj, ctx) {
     # TODO: Implement this function
     # to return the correct type for `obj`
     raise(NotImplementedError)

data/spec/graphql/relay/mutation_spec.rb

@@ -103,12 +103,14 @@ describe GraphQL::Relay::Mutation do
   end
 
   it "applies the description to the derived field" do
-    assert_equal "Add a ship to this faction", StarWars::IntroduceShipMutation.field.description
+    field = GraphQL::Schema::Field.from_options(name: "x", **StarWars::IntroduceShipMutation.field_options)
+    assert_equal "Add a ship to this faction", field.description
   end
 
   it "inserts itself into the derived objects' metadata" do
-    assert_equal StarWars::IntroduceShipMutation, StarWars::IntroduceShipMutation.field.mutation
-    assert_equal StarWars::IntroduceShipMutation, StarWars::IntroduceShipMutation.graphql_field.mutation
+    field = GraphQL::Schema::Field.from_options(name: "x", **StarWars::IntroduceShipMutation.field_options)
+    assert_equal StarWars::IntroduceShipMutation, field.mutation
+    assert_equal StarWars::IntroduceShipMutation, field.to_graphql.mutation
     assert_equal StarWars::IntroduceShipMutation, StarWars::IntroduceShipMutation.payload_type.mutation
     assert_equal StarWars::IntroduceShipMutation, StarWars::IntroduceShipMutation.input_type.mutation
   end

data/spec/graphql/schema/build_from_definition_spec.rb

@@ -668,7 +668,7 @@ type Type implements Interface {
       assert_equal [18, 1], schema.types["Union"].ast_node.position
       assert_equal [20, 1], schema.types["Scalar"].ast_node.position
       assert_equal [22, 1], schema.types["Input"].ast_node.position
-      assert_equal [22, 1], schema.types["Input"].arguments["argument"].ast_node.position
+      assert_equal [23, 3], schema.types["Input"].arguments["argument"].ast_node.position
       assert_equal [26, 1], schema.directives["Directive"].ast_node.position
       assert_equal [28, 3], schema.directives["Directive"].arguments["argument"].ast_node.position
       assert_equal [31, 22], schema.types["Type"].ast_node.interfaces[0].position

data/spec/graphql/schema/field_spec.rb

@@ -19,7 +19,7 @@ describe GraphQL::Schema::Field do
       assert_equal 'inspectInput', field.graphql_definition.name
       assert_equal 'inspectInput', field.name
 
-      underscored_field = GraphQL::Schema::Field.new(:underscored_field, String, null: false, camelize: false, owner: nil) do
+      underscored_field = GraphQL::Schema::Field.from_options(:underscored_field, String, null: false, camelize: false, owner: nil) do
         argument :underscored_arg, String, required: true, camelize: false
       end
 
@@ -55,7 +55,7 @@ describe GraphQL::Schema::Field do
       type = Class.new(GraphQL::Schema::Object) do
         graphql_name 'MyType'
       end
-      field = GraphQL::Schema::Field.new(:my_field, type, owner: nil, null: true)
+      field = GraphQL::Schema::Field.from_options(:my_field, type, owner: nil, null: true)
       assert_equal type.to_graphql, field.to_graphql.type
     end
 
@@ -210,33 +210,16 @@ describe GraphQL::Schema::Field do
   end
 
   describe "mutation" do
-    let(:mutation) do
-      Class.new(GraphQL::Schema::Mutation) do
+    it "passes when not including extra arguments" do
+      mutation_class = Class.new(GraphQL::Schema::Mutation) do
         graphql_name "Thing"
-
         field :stuff, String, null: false
       end
-    end
-    let(:error_message) { "when keyword `mutation:` is present, all arguments are ignored, please remove them" }
 
-    it "fails when including null option as true" do
-      error = assert_raises(ArgumentError) do
-        GraphQL::Schema::Field.new(:my_field, mutation: mutation, null: true)
+      obj = Class.new(GraphQL::Schema::Object) do
+        field(:my_field, mutation: mutation_class, null: true)
       end
-
-      assert_equal error.message, error_message
-    end
-
-    it "fails when including null option as false" do
-      error = assert_raises(ArgumentError) do
-        GraphQL::Schema::Field.new(:my_field, mutation: mutation, null: false)
-      end
-
-      assert_equal error.message, error_message
-    end
-
-    it "passes when not including extra arguments" do
-      assert_equal GraphQL::Schema::Field.new(:my_field, mutation: mutation).mutation, mutation
+      assert_equal obj.fields["myField"].mutation, mutation_class
     end
   end
 end

data/spec/graphql/schema/interface_spec.rb

@@ -157,4 +157,29 @@ describe GraphQL::Schema::Interface do
       assert_equal(expected_data, res["data"]["find"])
     end
   end
+
+  describe ':DefinitionMethods' do
+    module InterfaceA
+      include GraphQL::Schema::Interface
+    end
+
+    module InterfaceB
+      include GraphQL::Schema::Interface
+    end
+
+    module InterfaceC
+      include GraphQL::Schema::Interface
+    end
+
+    it "doesn't overwrite them when including multiple interfaces" do
+      def_methods = InterfaceC::DefinitionMethods
+
+      InterfaceC.module_eval do
+        include InterfaceA
+        include InterfaceB
+      end
+
+      assert_equal(InterfaceC::DefinitionMethods, def_methods)
+    end
+  end
 end

data/spec/graphql/schema/member/accepts_definition_spec.rb

@@ -46,6 +46,17 @@ describe GraphQL::Schema::Member::AcceptsDefinition do
       metadata2 :a, :bc
     end
 
+    module Thing2
+      include Thing
+    end
+
+    class SomeObject < BaseObject
+      metadata :a, :aaa
+    end
+
+    class SomeObject2 < SomeObject
+    end
+
     class Query < BaseObject
       metadata :a, :abc
       metadata2 :xyz, :zyx
@@ -56,6 +67,9 @@ describe GraphQL::Schema::Member::AcceptsDefinition do
       end
 
       field :thing, Thing, null: false
+      field :thing2, Thing2, null: false
+      field :some_object, SomeObject, null: false
+      field :some_object2, SomeObject2, null: false
     end
 
     query(Query)
@@ -71,6 +85,14 @@ describe GraphQL::Schema::Member::AcceptsDefinition do
     assert_equal [:z, 888], AcceptsDefinitionSchema::Thing.metadata
     assert_equal 888, AcceptsDefinitionSchema::Thing.graphql_definition.metadata[:z]
     assert_equal :bc, AcceptsDefinitionSchema::Thing.graphql_definition.metadata[:a]
+    # Interface inheritance
+    assert_equal [:z, 888], AcceptsDefinitionSchema::Thing2.metadata
+    assert_equal 888, AcceptsDefinitionSchema::Thing2.graphql_definition.metadata[:z]
+    assert_equal :bc, AcceptsDefinitionSchema::Thing2.graphql_definition.metadata[:a]
+
+    # Object inheritance
+    assert_equal :aaa, AcceptsDefinitionSchema::SomeObject.graphql_definition.metadata[:a]
+    assert_equal :aaa, AcceptsDefinitionSchema::SomeObject2.graphql_definition.metadata[:a]
   end
 
   it "passes along configs for fields and arguments" do

data/spec/graphql/schema/member/build_type_spec.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+require "spec_helper"
+
+describe GraphQL::Schema::Member::BuildType do
+  describe ".to_type_name" do
+    it "works with lists and non-nulls" do
+      t = Class.new(GraphQL::Schema::Object) do
+        graphql_name "T"
+      end
+
+      req_t = GraphQL::Schema::NonNull.new(t)
+      list_req_t = GraphQL::Schema::List.new(req_t)
+
+      assert_equal "T", GraphQL::Schema::Member::BuildType.to_type_name(list_req_t)
+    end
+  end
+end