graphql 2.4.10 → 2.4.11

data/lib/graphql/invalid_null_error.rb

@@ -2,7 +2,7 @@
 module GraphQL
   # Raised automatically when a field's resolve function returns `nil`
   # for a non-null field.
-  class InvalidNullError < GraphQL::RuntimeTypeError
+  class InvalidNullError < GraphQL::Error
     # @return [GraphQL::BaseType] The owner of {#field}
     attr_reader :parent_type
 
@@ -12,23 +12,17 @@ module GraphQL
     # @return [nil, GraphQL::ExecutionError] The invalid value for this field
     attr_reader :value
 
-    def initialize(parent_type, field, value)
+    # @return [GraphQL::Language::Nodes::Field] the field where the error occurred
+    attr_reader :ast_node
+
+    def initialize(parent_type, field, value, ast_node)
       @parent_type = parent_type
       @field = field
       @value = value
+      @ast_node = ast_node
       super("Cannot return null for non-nullable field #{@parent_type.graphql_name}.#{@field.graphql_name}")
     end
 
-    # @return [Hash] An entry for the response's "errors" key
-    def to_h
-      { "message" => message }
-    end
-
-    # @deprecated always false
-    def parent_error?
-      false
-    end
-
     class << self
       attr_accessor :parent_class
 

data/lib/graphql/schema/build_from_definition.rb

@@ -298,7 +298,6 @@ module GraphQL
                 description: enum_value_definition.description,
                 directives: builder.prepare_directives(enum_value_definition, type_resolver),
                 ast_node: enum_value_definition,
-                value_method: GraphQL::Schema::Enum.respond_to?(enum_value_definition.name.downcase) ? false : nil,
               )
             end
           end

data/lib/graphql/schema/enum.rb

@@ -70,7 +70,9 @@ module GraphQL
           kwargs[:owner] = self
           value = enum_value_class.new(*args, **kwargs, &block)
 
-          generate_value_method(value, value_method)
+          if value_method || (value_methods && value_method != false)
+            generate_value_method(value, value_method)
+          end
 
           key = value.graphql_name
           prev_value = own_values[key]
@@ -159,6 +161,18 @@ module GraphQL
           end
         end
 
+        def value_methods(new_value = NOT_CONFIGURED)
+          if NOT_CONFIGURED.equal?(new_value)
+            if @value_methods != nil
+              @value_methods
+            else
+              find_inherited_value(:value_methods, false)
+            end
+          else
+            @value_methods = new_value
+          end
+        end
+
         def kind
           GraphQL::TypeKinds::ENUM
         end
@@ -220,6 +234,7 @@ module GraphQL
             # because they would end up with names like `#<Class0x1234>::UnresolvedValueError` which messes up bug trackers
             child_class.const_set(:UnresolvedValueError, Class.new(Schema::Enum::UnresolvedValueError))
           end
+          child_class.class_eval { @value_methods = nil }
           super
         end
 

data/lib/graphql/schema/input_object.rb

@@ -156,7 +156,7 @@ module GraphQL
               def #{method_name}
                 self[#{method_name.inspect}]
               end
-              alias_method :#{method_name}, :#{method_name}
+              alias_method #{method_name.inspect}, #{method_name.inspect}
             RUBY
           end
           argument_defn

data/lib/graphql/schema/loader.rb

@@ -108,7 +108,6 @@ module GraphQL
                   enum_value["name"],
                   description: enum_value["description"],
                   deprecation_reason: enum_value["deprecationReason"],
-                  value_method: respond_to?(enum_value["name"].downcase) ? false : nil
                 )
               end
             end

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

@@ -23,6 +23,10 @@ module GraphQL
         # @param find_by_value [Object] Usually an `id`, might be another value if `find_by:` is also provided
         # @param find_by [Symbol, String] A column name to look the record up by. (Defaults to the model's primary key.)
         # @return [ActiveRecord::Base, nil]
+        # @example Finding a record by ID
+        #   dataload_record(Post, 5) # Like `Post.find(5)`, but dataloaded
+        # @example Finding a record by another attribute
+        #   dataload_record(User, "matz", find_by: :handle) # Like `User.find_by(handle: "matz")`, but dataloaded
         def dataload_record(model, find_by_value, find_by: nil)
           source = if find_by
             dataloader.with(Dataloader::ActiveRecordSource, model, find_by: find_by)

data/lib/graphql/schema.rb

@@ -1298,7 +1298,10 @@ module GraphQL
       def type_error(type_error, ctx)
         case type_error
         when GraphQL::InvalidNullError
-          ctx.errors << type_error
+          execution_error = GraphQL::ExecutionError.new(type_error.message, ast_node: type_error.ast_node)
+          execution_error.path = ctx[:current_path]
+
+          ctx.errors << execution_error
         when GraphQL::UnresolvedTypeError, GraphQL::StringEncodingError, GraphQL::IntegerEncodingError
           raise type_error
         when GraphQL::IntegerDecodingError
@@ -1366,6 +1369,16 @@ module GraphQL
         }.freeze
       end
 
+      # @return [GraphQL::Tracing::DetailedTrace] if it has been configured for this schema
+      attr_accessor :detailed_trace
+
+      # @param query [GraphQL::Query, GraphQL::Execution::Multiplex] Called with a multiplex when multiple queries are executed at once (with {.multiplex})
+      # @return [Boolean] When `true`, save a detailed trace for this query.
+      # @see Tracing::DetailedTrace DetailedTrace saves traces when this method returns true
+      def detailed_trace?(query)
+        raise "#{self} must implement `def.detailed_trace?(query)` to use DetailedTrace. Implement this method in your schema definition."
+      end
+
       def tracer(new_tracer, silence_deprecation_warning: false)
         if !silence_deprecation_warning
           warn("`Schema.tracer(#{new_tracer.inspect})` is deprecated; use module-based `trace_with` instead. See: https://graphql-ruby.org/queries/tracing.html")
@@ -1383,14 +1396,22 @@ module GraphQL
         find_inherited_value(:tracers, EMPTY_ARRAY) + own_tracers
       end
 
-      # Mix `trace_mod` into this schema's `Trace` class so that its methods
-      # will be called at runtime.
+      # Mix `trace_mod` into this schema's `Trace` class so that its methods will be called at runtime.
+      #
+      # You can attach a module to run in only _some_ circumstances by using `mode:`. When a module is added with `mode:`,
+      # it will only run for queries with a matching `context[:trace_mode]`.
+      #
+      # Any custom trace modes _also_ include the default `trace_with ...` modules (that is, those added _without_ any particular `mode: ...` configuration).
+      #
+      # @example Adding a trace in a special mode
+      #   # only runs when `query.context[:trace_mode]` is `:special`
+      #   trace_with SpecialTrace, mode: :special
       #
       # @param trace_mod [Module] A module that implements tracing methods
       # @param mode [Symbol] Trace module will only be used for this trade mode
       # @param options [Hash] Keywords that will be passed to the tracing class during `#initialize`
       # @return [void]
-      # @see GraphQL::Tracing::Trace for available tracing methods
+      # @see GraphQL::Tracing::Trace Tracing::Trace for available tracing methods
       def trace_with(trace_mod, mode: :default, **options)
         if mode.is_a?(Array)
           mode.each { |m| trace_with(trace_mod, mode: m, **options) }
@@ -1440,12 +1461,33 @@ module GraphQL
       #
       # If no `mode:` is given, then {default_trace_mode} will be used.
       #
+      # If this schema is using {Tracing::DetailedTrace} and {.detailed_trace?} returns `true`, then
+      # DetailedTrace's mode will override the passed-in `mode`.
+      #
       # @param mode [Symbol] Trace modules for this trade mode will be included
       # @param options [Hash] Keywords that will be passed to the tracing class during `#initialize`
       # @return [Tracing::Trace]
       def new_trace(mode: nil, **options)
-        target = options[:query] || options[:multiplex]
-        mode ||= target && target.context[:trace_mode]
+        should_sample = if detailed_trace
+          if (query = options[:query])
+            detailed_trace?(query)
+          elsif (multiplex = options[:multiplex])
+            if multiplex.queries.length == 1
+              detailed_trace?(multiplex.queries.first)
+            else
+              detailed_trace?(multiplex)
+            end
+          end
+        else
+          false
+        end
+
+        if should_sample
+          mode = detailed_trace.trace_mode
+        else
+          target = options[:query] || options[:multiplex]
+          mode ||= target && target.context[:trace_mode]
+        end
 
         trace_mode = mode || default_trace_mode
         base_trace_options = trace_options_for(trace_mode)

data/lib/graphql/tracing/active_support_notifications_trace.rb

@@ -4,8 +4,12 @@ require "graphql/tracing/notifications_trace"
 
 module GraphQL
   module Tracing
-    # This implementation forwards events to ActiveSupport::Notifications
-    # with a `graphql` suffix.
+    # This implementation forwards events to ActiveSupport::Notifications with a `graphql` suffix.
+    #
+    # @example Sending execution events to ActiveSupport::Notifications
+    #   class MySchema < GraphQL::Schema
+    #     trace_with(GraphQL::Tracing::ActiveSupportNotificationsTrace)
+    #   end
     module ActiveSupportNotificationsTrace
       include NotificationsTrace
       def initialize(engine: ActiveSupport::Notifications, **rest)

data/lib/graphql/tracing/appoptics_trace.rb

@@ -22,10 +22,12 @@ module GraphQL
       # These GraphQL events will show up as 'graphql.execute' spans
       EXEC_KEYS = ['execute_multiplex', 'execute_query', 'execute_query_lazy'].freeze
 
+
       # During auto-instrumentation this version of AppOpticsTracing is compared
       # with the version provided in the appoptics_apm gem, so that the newer
       # version of the class can be used
 
+
       def self.version
         Gem::Version.new('1.0.0')
       end

data/lib/graphql/tracing/appsignal_trace.rb

@@ -4,6 +4,12 @@ require "graphql/tracing/platform_trace"
 
 module GraphQL
   module Tracing
+    # Instrumentation for reporting GraphQL-Ruby times to Appsignal.
+    #
+    # @example Installing the tracer
+    #   class MySchema < GraphQL::Schema
+    #     trace_with GraphQL::Tracing::AppsignalTrace
+    #   end
     module AppsignalTrace
       include PlatformTrace
 

data/lib/graphql/tracing/data_dog_trace.rb

@@ -4,6 +4,11 @@ require "graphql/tracing/platform_trace"
 
 module GraphQL
   module Tracing
+    # A tracer for reporting to DataDog
+    # @example Adding this tracer to your schema
+    #   class MySchema < GraphQL::Schema
+    #     trace_with GraphQL::Tracing::DataDogTrace
+    #   end
     module DataDogTrace
       # @param tracer [#trace] Deprecated
       # @param analytics_enabled [Boolean] Deprecated

data/lib/graphql/tracing/detailed_trace/memory_backend.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+module GraphQL
+  module Tracing
+    class DetailedTrace
+      # An in-memory trace storage backend. Suitable for testing and development only.
+      # It won't work for multi-process deployments and everything is erased when the app is restarted.
+      class MemoryBackend
+        def initialize(limit: nil)
+          @limit = limit
+          @traces = {}
+          @next_id = 0
+        end
+
+        def traces(last:, before:)
+          page = []
+          @traces.values.reverse_each do |trace|
+            if page.size == last
+              break
+            elsif before.nil? || trace.begin_ms < before
+              page << trace
+            end
+          end
+          page
+        end
+
+        def find_trace(id)
+          @traces[id]
+        end
+
+        def delete_trace(id)
+          @traces.delete(id.to_i)
+          nil
+        end
+
+        def delete_all_traces
+          @traces.clear
+          nil
+        end
+
+        def save_trace(operation_name, duration, begin_ms, trace_data)
+          id = @next_id
+          @next_id += 1
+          @traces[id] = DetailedTrace::StoredTrace.new(
+            id: id,
+            operation_name: operation_name,
+            duration_ms: duration,
+            begin_ms: begin_ms,
+            trace_data: trace_data
+          )
+          if @limit && @traces.size > @limit
+            del_keys = @traces.keys[0...-@limit]
+            del_keys.each { |k| @traces.delete(k) }
+          end
+          id
+        end
+      end
+    end
+  end
+end

data/lib/graphql/tracing/detailed_trace/redis_backend.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+module GraphQL
+  module Tracing
+    class DetailedTrace
+      class RedisBackend
+        KEY_PREFIX = "gql:trace:"
+        def initialize(redis:, limit: nil)
+          @redis = redis
+          @key = KEY_PREFIX + "traces"
+          @remrangebyrank_limit = limit ? -limit - 1 : nil
+        end
+
+        def traces(last:, before:)
+          before = case before
+          when Numeric
+            "(#{before}"
+          when nil
+            "+inf"
+          end
+          str_pairs = @redis.zrange(@key, before, 0, byscore: true, rev: true, limit: [0, last || 100], withscores: true)
+          str_pairs.map do |(str_data, score)|
+            entry_to_trace(score, str_data)
+          end
+        end
+
+        def delete_trace(id)
+          @redis.zremrangebyscore(@key, id, id)
+          nil
+        end
+
+        def delete_all_traces
+          @redis.del(@key)
+        end
+
+        def find_trace(id)
+          str_data = @redis.zrange(@key, id, id, byscore: true).first
+          if str_data.nil?
+            nil
+          else
+            entry_to_trace(id, str_data)
+          end
+        end
+
+        def save_trace(operation_name, duration_ms, begin_ms, trace_data)
+          id = begin_ms
+          data = JSON.dump({ "o" => operation_name, "d" => duration_ms, "b" => begin_ms, "t" => Base64.encode64(trace_data) })
+          @redis.pipelined do |pipeline|
+            pipeline.zadd(@key, id, data)
+            if @remrangebyrank_limit
+              pipeline.zremrangebyrank(@key, 0, @remrangebyrank_limit)
+            end
+          end
+          id
+        end
+
+        private
+
+        def entry_to_trace(id, json_str)
+          data = JSON.parse(json_str)
+          StoredTrace.new(
+            id: id,
+            operation_name: data["o"],
+            duration_ms: data["d"].to_f,
+            begin_ms: data["b"].to_i,
+            trace_data: Base64.decode64(data["t"]),
+          )
+        end
+      end
+    end
+  end
+end

data/lib/graphql/tracing/detailed_trace.rb

@@ -0,0 +1,93 @@
+# frozen_string_literal: true
+require "graphql/tracing/detailed_trace/memory_backend"
+require "graphql/tracing/detailed_trace/redis_backend"
+
+module GraphQL
+  module Tracing
+    # `DetailedTrace` can make detailed profiles for a subset of production traffic.
+    #
+    # When `MySchema.detailed_trace?(query)` returns `true`, a profiler-specific `trace_mode: ...` will be used for the query,
+    # overriding the one in `context[:trace_mode]`.
+    #
+    # __Redis__: The sampler stores its results in a provided Redis database. Depending on your needs,
+    # You can configure this database to retail all data (persistent) or to expire data according to your rules.
+    # If you need to save traces indefinitely, you can download them from Perfetto after opening them there.
+    #
+    # @example Adding the sampler to your schema
+    #   class MySchema < GraphQL::Schema
+    #     # Add the sampler:
+    #     use GraphQL::Tracing::DetailedTrace, redis: Redis.new(...), limit: 100
+    #
+    #     # And implement this hook to tell it when to take a sample:
+    #     def self.detailed_trace?(query)
+    #       # Could use `query.context`, `query.selected_operation_name`, `query.query_string` here
+    #       # Could call out to Flipper, etc
+    #       rand <= 0.000_1 # one in ten thousand
+    #     end
+    #   end
+    #
+    # @see Graphql::Dashboard GraphQL::Dashboard for viewing stored results
+    class DetailedTrace
+      # @param redis [Redis] If provided, profiles will be stored in Redis for later review
+      # @param limit [Integer] A maximum number of profiles to store
+      def self.use(schema, trace_mode: :profile_sample, memory: false, redis: nil, limit: nil)
+        storage = if redis
+          RedisBackend.new(redis: redis, limit: limit)
+        elsif memory
+          MemoryBackend.new(limit: limit)
+        else
+          raise ArgumentError, "Pass `redis: ...` to store traces in Redis for later review"
+        end
+        schema.detailed_trace = self.new(storage: storage, trace_mode: trace_mode)
+        schema.trace_with(PerfettoTrace, mode: trace_mode, save_profile: true)
+      end
+
+      def initialize(storage:, trace_mode:)
+        @storage = storage
+        @trace_mode = trace_mode
+      end
+
+      # @return [Symbol] The trace mode to use when {Schema.detailed_trace?} returns `true`
+      attr_reader :trace_mode
+
+      # @return [String] ID of saved trace
+      def save_trace(operation_name, duration_ms, begin_ms, trace_data)
+        @storage.save_trace(operation_name, duration_ms, begin_ms, trace_data)
+      end
+
+      # @param last [Integer]
+      # @param before [Integer] Timestamp in milliseconds since epoch
+      # @return [Enumerable<StoredTrace>]
+      def traces(last: nil, before: nil)
+        @storage.traces(last: last, before: before)
+      end
+
+      # @return [StoredTrace, nil]
+      def find_trace(id)
+        @storage.find_trace(id)
+      end
+
+      # @return [void]
+      def delete_trace(id)
+        @storage.delete_trace(id)
+      end
+
+      # @return [void]
+      def delete_all_traces
+        @storage.delete_all_traces
+      end
+
+      class StoredTrace
+        def initialize(id:, operation_name:, duration_ms:, begin_ms:, trace_data:)
+          @id = id
+          @operation_name = operation_name
+          @duration_ms = duration_ms
+          @begin_ms = begin_ms
+          @trace_data = trace_data
+        end
+
+        attr_reader :id, :operation_name, :duration_ms, :begin_ms, :trace_data
+      end
+    end
+  end
+end

data/lib/graphql/tracing/new_relic_trace.rb

@@ -4,6 +4,15 @@ require "graphql/tracing/platform_trace"
 
 module GraphQL
   module Tracing
+    # A tracer for reporting GraphQL-Ruby time to New Relic
+    #
+    # @example Installing the tracer
+    #   class MySchema < GraphQL::Schema
+    #     trace_with GraphQL::Tracing::NewRelicTrace
+    #
+    #     # Optional, use the operation name to set the new relic transaction name:
+    #     # trace_with GraphQL::Tracing::NewRelicTrace, set_transaction_name: true
+    #   end
     module NewRelicTrace
       # @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.

data/lib/graphql/tracing/perfetto_trace.rb

@@ -61,8 +61,10 @@ module GraphQL
       DA_STR_VAL_NIL_IID = 14
 
       # @param active_support_notifications_pattern [String, RegExp, false] A filter for `ActiveSupport::Notifications`, if it's present. Or `false` to skip subscribing.
-      def initialize(active_support_notifications_pattern: nil, **_rest)
+      def initialize(active_support_notifications_pattern: nil, save_profile: false, **_rest)
         super
+        @save_profile = save_profile
+        Fiber[:graphql_flow_stack] = nil
         @sequence_id = object_id
         @pid = Process.pid
         @flow_ids = Hash.new { |h, source_inst| h[source_inst] = [] }.compare_by_identity
@@ -108,6 +110,7 @@ module GraphQL
         @fibers_counter_id = :fibers_counter.object_id
         @fields_counter_id = :fields_counter.object_id
         @begin_validate = nil
+        @begin_time = nil
         @packets = []
         @packets << TracePacket.new(
           track_descriptor: TrackDescriptor.new(
@@ -172,6 +175,8 @@ module GraphQL
       end
 
       def begin_execute_multiplex(m)
+        @operation_name = m.queries.map { |q| q.selected_operation_name || "anonymous" }.join(",")
+        @begin_time = Time.now
         @packets << trace_packet(
           type: TrackEvent::Type::TYPE_SLICE_BEGIN,
           track_uuid: fid,
@@ -189,6 +194,12 @@ module GraphQL
           track_uuid: fid,
         )
         unsubscribe_from_active_support_notifications
+        if @save_profile
+          begin_ts = (@begin_time.to_f * 1000).round
+          end_ts = (Time.now.to_f * 1000).round
+          duration_ms = end_ts - begin_ts
+          m.schema.detailed_trace.save_trace(@operation_name, duration_ms, begin_ts, Trace.encode(Trace.new(packet: @packets)))
+        end
         super
       end
 
@@ -297,7 +308,7 @@ module GraphQL
           {
             debug_annotations: [
               @begin_validate.track_event.debug_annotations.first,
-              payload_to_debug("valid?", !validation_errors.empty?)
+              payload_to_debug("valid?", validation_errors.empty?)
             ]
           }
         )

data/lib/graphql/tracing/prometheus_trace.rb

@@ -4,6 +4,28 @@ require "graphql/tracing/platform_trace"
 
 module GraphQL
   module Tracing
+    # A tracer for reporting GraphQL-Ruby times to Prometheus.
+    #
+    # The PrometheusExporter server must be run with a custom type collector that extends `GraphQL::Tracing::PrometheusTracing::GraphQLCollector`.
+    #
+    # @example Adding this trace to your schema
+    #   require 'prometheus_exporter/client'
+    #
+    #   class MySchema < GraphQL::Schema
+    #     trace_with GraphQL::Tracing::PrometheusTrace
+    #   end
+    #
+    # @example Running a custom type collector
+    #   # lib/graphql_collector.rb
+    #   if defined?(PrometheusExporter::Server)
+    #     require 'graphql/tracing'
+    #
+    #     class GraphQLCollector < GraphQL::Tracing::PrometheusTrace::GraphQLCollector
+    #     end
+    #   end
+    #
+    #    # Then run:
+    #    # bundle exec prometheus_exporter -a lib/graphql_collector.rb
     module PrometheusTrace
       if defined?(PrometheusExporter::Server)
         autoload :GraphQLCollector, "graphql/tracing/prometheus_trace/graphql_collector"

data/lib/graphql/tracing/scout_trace.rb

@@ -4,6 +4,12 @@ require "graphql/tracing/platform_trace"
 
 module GraphQL
   module Tracing
+    # A tracer for sending GraphQL-Ruby times to Scout
+    #
+    # @example Adding this tracer to your schema
+    #   class MySchema < GraphQL::Schema
+    #     trace_with GraphQL::Tracing::ScoutTrace
+    #   end
     module ScoutTrace
       include PlatformTrace
 

data/lib/graphql/tracing/sentry_trace.rb

@@ -4,6 +4,11 @@ require "graphql/tracing/platform_trace"
 
 module GraphQL
   module Tracing
+    # A tracer for reporting GraphQL-Ruby times to Sentry.
+    # @example Installing the tracer
+    #   class MySchema < GraphQL::Schema
+    #     trace_with GraphQL::Tracing::SentryTrace
+    #   end
     module SentryTrace
       include PlatformTrace
 

data/lib/graphql/tracing/statsd_trace.rb

@@ -4,6 +4,15 @@ require "graphql/tracing/platform_trace"
 
 module GraphQL
   module Tracing
+    # A tracer for reporting GraphQL-Ruby times to Statsd.
+    # Passing any Statsd client that implements `.time(name) { ... }` will work.
+    #
+    # @example Installing this tracer
+    #   # eg:
+    #   # $statsd = Statsd.new 'localhost', 9125
+    #   class MySchema < GraphQL::Schema
+    #     use GraphQL::Tracing::StatsdTrace, statsd: $statsd
+    #   end
     module StatsdTrace
       include PlatformTrace
 

data/lib/graphql/tracing.rb

@@ -32,6 +32,7 @@ module GraphQL
     autoload :StatsdTrace, "graphql/tracing/statsd_trace"
     autoload :PrometheusTrace, "graphql/tracing/prometheus_trace"
     autoload :PerfettoTrace, "graphql/tracing/perfetto_trace"
+    autoload :DetailedTrace, "graphql/tracing/detailed_trace"
 
     # Objects may include traceable to gain a `.trace(...)` method.
     # The object must have a `@tracers` ivar of type `Array<<#trace(k, d, &b)>>`.

data/lib/graphql/version.rb

@@ -1,4 +1,4 @@
 # frozen_string_literal: true
 module GraphQL
-  VERSION = "2.4.10"
+  VERSION = "2.4.11"
 end

data/lib/graphql.rb

@@ -125,6 +125,9 @@ This is probably a bug in GraphQL-Ruby, please report this error on GitHub: http
   autoload :LoadApplicationObjectFailedError, "graphql/load_application_object_failed_error"
   autoload :Testing, "graphql/testing"
   autoload :Current, "graphql/current"
+  if defined?(::Rails::Engine)
+    autoload :Dashboard, 'graphql/dashboard'
+  end
 end
 
 require "graphql/version"