graphql 1.10.0.pre1 → 1.10.0.pre2

data/lib/graphql/static_validation/rules/fields_are_defined_on_type.rb

@@ -9,16 +9,16 @@ module GraphQL
         if field.nil?
           if parent_type.kind.union?
             add_error(GraphQL::StaticValidation::FieldsHaveAppropriateSelectionsError.new(
-              "Selections can't be made directly on unions (see selections on #{parent_type.name})",
+              "Selections can't be made directly on unions (see selections on #{parent_type.graphql_name})",
               nodes: parent,
-              node_name: parent_type.name
+              node_name: parent_type.graphql_name
             ))
           else
             add_error(GraphQL::StaticValidation::FieldsAreDefinedOnTypeError.new(
-              "Field '#{node.name}' doesn't exist on type '#{parent_type.name}'",
+              "Field '#{node.name}' doesn't exist on type '#{parent_type.graphql_name}'",
               nodes: node,
               field: node.name,
-              type: parent_type.name
+              type: parent_type.graphql_name
             ))
           end
         else

data/lib/graphql/static_validation/rules/fragment_spreads_are_possible.rb

@@ -50,12 +50,12 @@ module GraphQL
         if child_types.none? { |c| parent_types.include?(c) }
           name = node.respond_to?(:name) ? " #{node.name}" : ""
           add_error(GraphQL::StaticValidation::FragmentSpreadsArePossibleError.new(
-            "Fragment#{name} on #{child_type.name} can't be spread inside #{parent_type.name}",
+            "Fragment#{name} on #{child_type.graphql_name} can't be spread inside #{parent_type.graphql_name}",
             nodes: node,
             path: path,
             fragment_name: name.empty? ? "unknown" : name,
-            type: child_type.name,
-            parent: parent_type.name
+            type: child_type.graphql_name,
+            parent: parent_type.graphql_name
           ))
         end
       end

data/lib/graphql/static_validation/type_stack.rb

@@ -55,7 +55,7 @@ module GraphQL
       module FragmentWithTypeStrategy
         def push(stack, node)
           object_type = if node.type
-            stack.schema.types.fetch(node.type.name, nil)
+            stack.schema.get_type(node.type.name)
           else
             stack.object_types.last
           end
@@ -148,7 +148,7 @@ module GraphQL
           if stack.argument_definitions.last
             arg_type = stack.argument_definitions.last.type.unwrap
             if arg_type.kind.input_object?
-              argument_defn = arg_type.input_fields[node.name]
+              argument_defn = arg_type.arguments[node.name]
             else
               argument_defn = nil
             end

data/lib/graphql/static_validation/validator.rb

@@ -23,7 +23,7 @@ module GraphQL
       # @return [Array<Hash>]
       def validate(query, validate: true)
         query.trace("validate", { validate: validate, query: query }) do
-          can_skip_rewrite = query.context.interpreter? && query.schema.using_ast_analysis?
+          can_skip_rewrite = query.context.interpreter? && query.schema.using_ast_analysis? && query.schema.is_a?(Class)
           errors = if validate == false && can_skip_rewrite
             []
           else

data/lib/graphql/subscriptions.rb

@@ -18,12 +18,17 @@ module GraphQL
 
     # @see {Subscriptions#initialize} for options, concrete implementations may add options.
     def self.use(defn, options = {})
-      schema = defn.target
-      options[:schema] = schema
-      schema.subscriptions = self.new(options)
+      schema = defn.is_a?(Class) ? defn : defn.target
+
+      if schema.subscriptions
+        raise ArgumentError, "Can't reinstall subscriptions. #{schema} is using #{schema.subscriptions}, can't also add #{self}"
+      end
+
       instrumentation = Subscriptions::Instrumentation.new(schema: schema)
-      defn.instrument(:field, instrumentation)
       defn.instrument(:query, instrumentation)
+      defn.instrument(:field, instrumentation)
+      options[:schema] = schema
+      schema.subscriptions = self.new(options)
       nil
     end
 
@@ -124,7 +129,7 @@ module GraphQL
     # @yieldparam subscription_id [String]
     # @return [void]
     def each_subscription_id(event)
-      raise NotImplementedError
+      raise GraphQL::RequiredImplementationMissingError
     end
 
     # The system wants to send an update to this subscription.
@@ -132,7 +137,7 @@ module GraphQL
     # @param subscription_id [String]
     # @return [Hash] Containing required keys
     def read_subscription(subscription_id)
-      raise NotImplementedError
+      raise GraphQL::RequiredImplementationMissingError
     end
 
     # A subscription query was re-evaluated, returning `result`.
@@ -141,7 +146,7 @@ module GraphQL
     # @param result [Hash]
     # @return [void]
     def deliver(subscription_id, result)
-      raise NotImplementedError
+      raise GraphQL::RequiredImplementationMissingError
     end
 
     # `query` was executed and found subscriptions to `events`.
@@ -150,7 +155,7 @@ module GraphQL
     # @param events [Array<GraphQL::Subscriptions::Event>]
     # @return [void]
     def write_subscription(query, events)
-      raise NotImplementedError
+      raise GraphQL::RequiredImplementationMissingError
     end
 
     # A subscription was terminated server-side.
@@ -158,7 +163,7 @@ module GraphQL
     # @param subscription_id [String]
     # @return void.
     def delete_subscription(subscription_id)
-      raise NotImplementedError
+      raise GraphQL::RequiredImplementationMissingError
     end
 
     # @return [String] A new unique identifier for a subscription
@@ -188,7 +193,11 @@ module GraphQL
     # @return [Any] normalized arguments value
     def normalize_arguments(event_name, arg_owner, args)
       case arg_owner
-      when GraphQL::Field, GraphQL::InputObjectType
+      when GraphQL::Field, GraphQL::InputObjectType, GraphQL::Schema::Field, Class
+        if arg_owner.is_a?(Class) && !arg_owner.kind.input_object?
+          # it's a type, but not an input object
+          return args
+        end
         normalized_args = {}
         missing_arg_names = []
         args.each do |k, v|
@@ -202,16 +211,32 @@ module GraphQL
           end
 
           if arg_defn
-            normalized_args[normalized_arg_name] = normalize_arguments(event_name, arg_defn.type, v)
+            if arg_defn.loads
+              normalized_arg_name = arg_defn.keyword.to_s
+            end
+            normalized = normalize_arguments(event_name, arg_defn.type, v)
+            normalized_args[normalized_arg_name] = normalized
           else
             # Couldn't find a matching argument definition
             missing_arg_names << arg_name
           end
         end
 
+        # Backfill default values so that trigger arguments
+        # match query arguments.
+        arg_owner.arguments.each do |name, arg_defn|
+          if arg_defn.default_value? && !normalized_args.key?(arg_defn.name)
+            normalized_args[arg_defn.name] = arg_defn.default_value
+          end
+        end
+
         if missing_arg_names.any?
           arg_owner_name = if arg_owner.is_a?(GraphQL::Field)
             "Subscription.#{arg_owner.name}"
+          elsif arg_owner.is_a?(GraphQL::Schema::Field)
+            arg_owner.path
+          elsif arg_owner.is_a?(Class)
+            arg_owner.graphql_name
           else
             arg_owner.to_s
           end
@@ -219,9 +244,9 @@ module GraphQL
         end
 
         normalized_args
-      when GraphQL::ListType
+      when GraphQL::ListType, GraphQL::Schema::List
         args.map { |a| normalize_arguments(event_name, arg_owner.of_type, a) }
-      when GraphQL::NonNullType
+      when GraphQL::NonNullType, GraphQL::Schema::NonNull
         normalize_arguments(event_name, arg_owner.of_type, args)
       else
         args

data/lib/graphql/subscriptions/event.rb

@@ -37,7 +37,7 @@ module GraphQL
           arguments
         when Hash
           if field.is_a?(GraphQL::Schema::Field)
-            stringify_args(arguments)
+            stringify_args(field, arguments)
           else
             GraphQL::Query::LiteralInput.from_arguments(
               arguments,
@@ -49,27 +49,44 @@ module GraphQL
           raise ArgumentError, "Unexpected arguments: #{arguments}, must be Hash or GraphQL::Arguments"
         end
 
-        sorted_h = normalized_args.to_h.sort.to_h
+        sorted_h = stringify_args(field, normalized_args.to_h)
         Serialize.dump_recursive([scope, name, sorted_h])
       end
 
       class << self
         private
-        def stringify_args(args)
+        def stringify_args(arg_owner, args)
           case args
           when Hash
             next_args = {}
             args.each do |k, v|
-              str_k = GraphQL::Schema::Member::BuildType.camelize(k.to_s)
-              next_args[str_k] = stringify_args(v)
+              arg_name = k.to_s
+              camelized_arg_name = GraphQL::Schema::Member::BuildType.camelize(arg_name)
+              arg_defn = get_arg_definition(arg_owner, camelized_arg_name)
+
+              if arg_defn
+                normalized_arg_name = camelized_arg_name
+              else
+                normalized_arg_name = arg_name
+                arg_defn = get_arg_definition(arg_owner, normalized_arg_name)
+              end
+
+              next_args[normalized_arg_name] = stringify_args(arg_defn.type, v)
             end
-            next_args
+            # Make sure they're deeply sorted
+            next_args.sort.to_h
           when Array
-            args.map { |a| stringify_args(a) }
+            args.map { |a| stringify_args(arg_owner, a) }
+          when GraphQL::Schema::InputObject
+            stringify_args(arg_owner, args.to_h)
           else
             args
           end
         end
+
+        def get_arg_definition(arg_owner, arg_name)
+          arg_owner.arguments[arg_name] || arg_owner.arguments.each_value.find { |v| v.keyword.to_s == arg_name }
+        end
       end
     end
   end

data/lib/graphql/subscriptions/instrumentation.rb

@@ -11,7 +11,7 @@ module GraphQL
       end
 
       def instrument(type, field)
-        if type == @schema.subscription
+        if type == @schema.subscription.graphql_definition
           # This is a root field of `subscription`
           subscribing_resolve_proc = SubscriptionRegistrationResolve.new(field.resolve_proc)
           field.redefine(resolve: subscribing_resolve_proc)

data/lib/graphql/subscriptions/subscription_root.rb

@@ -44,7 +44,6 @@ module GraphQL
               context: context,
               field: field,
             )
-            # TODO compat with non-class-based subscriptions?
             value
           elsif context.query.subscription_topic == Subscriptions::Event.serialize(
               field.name,

data/lib/graphql/tracing/active_support_notifications_tracing.rb

@@ -8,19 +8,19 @@ module GraphQL
     module ActiveSupportNotificationsTracing
       # A cache of frequently-used keys to avoid needless string allocations
       KEYS = {
-        "lex" => "graphql.lex",
-        "parse" => "graphql.parse",
-        "validate" => "graphql.validate",
-        "analyze_multiplex" => "graphql.analyze_multiplex",
-        "analyze_query" => "graphql.analyze_query",
-        "execute_query" => "graphql.execute_query",
-        "execute_query_lazy" => "graphql.execute_query_lazy",
-        "execute_field" => "graphql.execute_field",
-        "execute_field_lazy" => "graphql.execute_field_lazy",
+        "lex" => "lex.graphql",
+        "parse" => "parse.graphql",
+        "validate" => "validate.graphql",
+        "analyze_multiplex" => "analyze_multiplex.graphql",
+        "analyze_query" => "analyze_query.graphql",
+        "execute_query" => "execute_query.graphql",
+        "execute_query_lazy" => "execute_query_lazy.graphql",
+        "execute_field" => "execute_field.graphql",
+        "execute_field_lazy" => "execute_field_lazy.graphql",
       }
 
       def self.trace(key, metadata)
-        prefixed_key = KEYS[key] || "graphql.#{key}"
+        prefixed_key = KEYS[key] || "#{key}.graphql"
         ActiveSupport::Notifications.instrument(prefixed_key, metadata) do
           yield
         end

data/lib/graphql/tracing/platform_tracing.rb

@@ -39,8 +39,7 @@ module GraphQL
             end
 
             return_type = field.type.unwrap
-            # Handle LateBoundTypes, which don't have `#kind`
-            trace_field = if return_type.respond_to?(:kind) && (return_type.kind.scalar? || return_type.kind.enum?)
+            trace_field = if return_type.kind.scalar? || return_type.kind.enum?
               (field.trace.nil? && @trace_scalars) || field.trace
             else
               true

data/lib/graphql/tracing/skylight_tracing.rb

@@ -18,6 +18,7 @@ module GraphQL
       #   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_skylight_endpoint_name]`.
       def initialize(options = {})
+        warn("GraphQL::Tracing::SkylightTracing is deprecated, please enable Skylight's GraphQL probe instead: https://www.skylight.io/support/getting-more-from-skylight#graphql.")
         @set_endpoint_name = options.fetch(:set_endpoint_name, false)
         super
       end

data/lib/graphql/unresolved_type_error.rb

@@ -24,8 +24,8 @@ module GraphQL
       @parent_type = parent_type
       @resolved_type = resolved_type
       @possible_types = possible_types
-      message = "The value from \"#{field.name}\" on \"#{parent_type}\" could not be resolved to \"#{field.type}\". " \
-        "(Received: `#{resolved_type.inspect}`, Expected: [#{possible_types.map(&:inspect).join(", ")}]) " \
+      message = "The value from \"#{field.graphql_name}\" on \"#{parent_type.graphql_name}\" could not be resolved to \"#{field.type.to_type_signature}\". " \
+        "(Received: `#{resolved_type.inspect}`, Expected: [#{possible_types.map(&:graphql_name).join(", ")}]) " \
         "Make sure you have defined a `resolve_type` proc on your schema and that value `#{value.inspect}` " \
         "gets resolved to a valid type. You may need to add your type to `orphan_types` if it implements an " \
         "interface but isn't a return type of any other field."

data/lib/graphql/upgrader/member.rb

@@ -13,7 +13,7 @@ module GraphQL
       # @param input_text [String] Untransformed GraphQL-Ruby code
       # @return [String] The input text, with a transformation applied if necessary
       def apply(input_text)
-        raise NotImplementedError, "Return transformed text here"
+        raise GraphQL::RequiredImplementationMissingError, "Return transformed text here"
       end
 
       # Recursively transform a `.define`-DSL-based type expression into a class-ready expression, for example:

data/lib/graphql/version.rb

@@ -1,4 +1,4 @@
 # frozen_string_literal: true
 module GraphQL
-  VERSION = "1.10.0.pre1"
+  VERSION = "1.10.0.pre2"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: graphql
 version: !ruby/object:Gem::Version
-  version: 1.10.0.pre1
+  version: 1.10.0.pre2
 platform: ruby
 authors:
 - Robert Mosolgo
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-10-10 00:00:00.000000000 Z
+date: 2019-12-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: benchmark-ips
@@ -340,6 +340,7 @@ files:
 - lib/generators/graphql/templates/base_field.erb
 - lib/generators/graphql/templates/base_input_object.erb
 - lib/generators/graphql/templates/base_interface.erb
+- lib/generators/graphql/templates/base_mutation.erb
 - lib/generators/graphql/templates/base_object.erb
 - lib/generators/graphql/templates/base_scalar.erb
 - lib/generators/graphql/templates/base_union.erb
@@ -546,6 +547,7 @@ files:
 - lib/graphql/schema/default_parse_error.rb
 - lib/graphql/schema/default_type_error.rb
 - lib/graphql/schema/directive.rb
+- lib/graphql/schema/directive/deprecated.rb
 - lib/graphql/schema/directive/feature.rb
 - lib/graphql/schema/directive/include.rb
 - lib/graphql/schema/directive/skip.rb
@@ -579,6 +581,7 @@ files:
 - lib/graphql/schema/member/relay_shortcuts.rb
 - lib/graphql/schema/member/scoped.rb
 - lib/graphql/schema/member/type_system_helpers.rb
+- lib/graphql/schema/member/validates_input.rb
 - lib/graphql/schema/middleware_chain.rb
 - lib/graphql/schema/mutation.rb
 - lib/graphql/schema/non_null.rb