graph_weaver 0.7.0 → 0.7.2

data/lib/graph_weaver/graph.rb

@@ -65,7 +65,24 @@ module GraphWeaver
 
     def queries = @queries || GraphWeaver.queries_paths
     def output = @output || GraphWeaver.generated_paths.first
-    def client = @client
+
+    # The client this graph's modules call: the object `client` named, or the
+    # constant its name spells. nil when the graph names none — its modules
+    # go to GraphWeaver.client, like every other module.
+    #
+    # Resolved here, at call time, rather than spelled into generated source:
+    # renaming the constant is then an initializer edit and not a regeneration
+    # of every module, and a graph can name a live object.
+    def client
+      return @client unless @client.is_a?(String)
+
+      Object.const_get(@client)
+    rescue NameError
+      raise GraphWeaver::Error, "the client#{described} names #{@client.inspect} and nothing " \
+        "defines that constant, so its modules have no server to reach. Define it where the graph " \
+        "block can see it (config/initializers), or name the object itself: client " \
+        "GraphWeaver.new(\"https://api.example.com/graphql\")"
+    end
 
     # Every constant this graph generates lives under `namespace:` — the query
     # modules and the shared types module alike. Two schemas that each have a
@@ -95,7 +112,7 @@ module GraphWeaver
 
     # The dump this graph's schema was named by, when it was named by a file —
     # what a validation error's subgraph branding is read off. nil for a live
-    # class, a Client, or inline SDL.
+    # class, inline SDL, or a Client built from any of those.
     def dump_path
       path = named_dump_path
       path if path && File.exist?(path)
@@ -109,6 +126,9 @@ module GraphWeaver
       return GraphWeaver::SchemaLoader.locate_path unless @schema
 
       source = named_source
+      # a client built from a dump names that dump: the file is where a
+      # supergraph's routing table is, and the loaded schema is not
+      source = source.schema_source if source.respond_to?(:schema_source) && source.schema_source
       path = source.respond_to?(:to_path) ? source.to_path : source
       path if path.is_a?(String) && GraphWeaver::SchemaLoader.dump_path?(path)
     end
@@ -133,26 +153,16 @@ module GraphWeaver
       url || live_schema
     end
 
-    # The url this graph's modules post to, or nil. `client:` holds a constant
-    # or its name — codegen spells it into source — so a name is resolved here
-    # the way the generated DEFAULT_CLIENT lambda resolves it; a graph baking
-    # none posts to the app default, which is where its modules go too.
+    # The url this graph's modules post to, or nil — the graph's own client,
+    # else the app default, which is where its modules go too. What
+    # `schema:refresh` bootstraps a missing dump from, and what `rake
+    # graph_weaver:graphs` reports; a client with no url (a schema class
+    # running in-process) has none to report.
     def client_url
-      client = @client.is_a?(String) ? resolve_client! : @client
-      client ||= GraphWeaver.client
-      target = (client.transport if client.respond_to?(:transport)) || client
+      target = client || GraphWeaver.client
+      target = (target.transport if target.respond_to?(:transport)) || target
       target.url if target.respond_to?(:url)
     end
-    private :client_url
-
-    def resolve_client!
-      Object.const_get(@client)
-    rescue NameError
-      raise GraphWeaver::Error, "graph #{name.inspect} bakes client #{@client.inspect} into its " \
-        "modules and nothing defines that constant, so there is no endpoint to introspect " \
-        "#{named_dump_path} from"
-    end
-    private :resolve_client!
 
     # The composed supergraph this graph plans against, or nil — the dump it
     # names (for the default graph, the conventional one) when that dump
@@ -222,13 +232,12 @@ module GraphWeaver
       # The same three calls an app already writes at the top level, scoped here
       # to this graph alone.
       REGISTRATIONS = %i[register_scalar register_enum extend_type].freeze
-      # These three end up spelled in generated source, so each takes the
-      # constant or its name and stores the name.
-      CONSTANT_SETTINGS = %i[client namespace types_module].freeze
-      # …and these two are spelled as a `module` DEFINITION rather than a
-      # reference, which is why a root anchor is refused on them below.
+      # These two are spelled in generated source, as a `module` DEFINITION,
+      # so each takes the constant or its name and stores the name — and a
+      # root anchor is refused on them below. `client` isn't spelled anywhere:
+      # the graph resolves it at call time, so it takes the object.
       MODULE_SETTINGS = %i[namespace types_module].freeze
-      private_constant :CONSTANT_SETTINGS, :MODULE_SETTINGS
+      private_constant :MODULE_SETTINGS
 
       attr_reader :settings, :registrations
 
@@ -283,17 +292,18 @@ module GraphWeaver
       def respond_to_missing?(name, _private = false) = false
 
       # A Module where a constant's name goes says the same thing, and is what
-      # `client Billing::CLIENT` reads like. Anything else passes through:
-      # a schema is a path, SDL, a class, a Client, or a callable.
+      # `namespace Billing` reads like. Anything else passes through: a schema
+      # is a path, SDL, a class, a Client, or a callable, and a client is
+      # whatever object answers #execute.
       # On the singleton so the define_method setters above can reach it — srb
       # reads a define_method block's self as the class.
       def self.constant_name(setting, value)
-        return value unless CONSTANT_SETTINGS.include?(setting)
+        return value unless MODULE_SETTINGS.include?(setting)
 
         # Generated modules are defined at the top level, where a root anchor
         # says nothing — and `module ::A::B` is not a name const_get can spell,
         # so it used to surface as a verdict on the .graphql file's name.
-        if MODULE_SETTINGS.include?(setting) && value.is_a?(String) && value.start_with?("::")
+        if value.is_a?(String) && value.start_with?("::")
           raise ArgumentError, "#{setting} #{value.inspect}: drop the leading `::` — #{setting} " \
             "names a module generated source defines, and it defines it at the top level either way"
         end

data/lib/graph_weaver/in_process.rb

@@ -5,6 +5,7 @@ require "json"
 
 require_relative "errors"
 require_relative "internal"
+require_relative "context_seam"
 require_relative "parsing"
 require_relative "transport"
 
@@ -32,13 +33,13 @@ require_relative "transport"
 # is usually the whole reason you're running in-process.
 class GraphWeaver::InProcess
   include GraphWeaver::Parsing
+  # #context/#context= plus the lock over them: Testing::Endpoint answers a
+  # `context:` proc from one request's headers by writing this field, so the
+  # field's owner owns the lock
+  include GraphWeaver::ContextSeam
 
-  # the schema queries run against, and the context handed to every one
-  attr_reader :schema, :context
-
-  # settable so Testing::Endpoint can answer a `context:` proc from the
-  # request's headers and put it back — the same seam Router#context= is
-  attr_writer :context
+  # the schema queries run against
+  attr_reader :schema
 
   def initialize(schema, context: {})
     unless schema.respond_to?(:execute)
@@ -46,12 +47,13 @@ class GraphWeaver::InProcess
     end
 
     @schema = schema
-    @context = context
+    init_context_seam(context)
   end
 
   def execute(query, variables: {}, operation_name: nil)
     operation_name ||= GraphWeaver::Internal::Wire.operation_name(query)
-    payload = { url: nil, schema: schema_label, operation: operation_name, client: self.class }
+    payload = { url: nil, schema: schema_label, operation: operation_name, client: self.class,
+                kind: GraphWeaver::Internal::Wire.kind(query) }
 
     GraphWeaver::Internal::Log.instrument(GraphWeaver::EXECUTE_EVENT, payload) do
       perform(query, variables, operation_name)
@@ -84,7 +86,11 @@ class GraphWeaver::InProcess
     # a resolver blew up. The same failure over HTTP arrives as a 500, so
     # raise what HTTP would — code that rescues GraphWeaver::Error, or
     # branches on ServerError#status, behaves the same either side.
-    raise GraphWeaver::ServerError.new(status: 500, body: "#{e.class}: #{e.message}")
+    # detail:, not body: — there was no response, so there are no bytes to
+    # hold, and the diagnosis is this process's own exception
+    raise GraphWeaver::ServerError.new(
+      status: 500, detail: "#{e.class}: #{GraphWeaver::Internal::Redact.cap(e.message)}",
+    )
   end
 
   # never leak the context (session tokens, current_user) through logs or

data/lib/graph_weaver/internal/endpoint.rb

@@ -54,20 +54,22 @@ module GraphWeaver
         def drop_secrets(query)
           kept = query.split("&").reject do |pair|
             name, value = pair.split("=", 2)
-            value && Redact.filtered?(URI.decode_www_form_component(name))
+            value && Redact.credential?(URI.decode_www_form_component(name))
           end
           kept.join("&") unless kept.empty?
         end
 
         # Which query parameters are secret is the same question
         # GraphWeaver.filter_parameters already answers for variables, so a
-        # scrubbed log reads the same either side of the seam. Split rather
-        # than decoded and re-encoded: every parameter that stays is printed
-        # exactly as it was sent.
+        # scrubbed log reads the same either side of the seam — widened by the
+        # default names, which apply here even when the app has emptied its
+        # list (see Redact.credential?). Split rather than decoded and
+        # re-encoded: every parameter that stays is printed exactly as it was
+        # sent.
         def scrub_query(query)
           query.split("&").map do |pair|
             name, value = pair.split("=", 2)
-            next pair if value.nil? || !Redact.filtered?(URI.decode_www_form_component(name))
+            next pair if value.nil? || !Redact.credential?(URI.decode_www_form_component(name))
 
             "#{name}=#{GraphWeaver::FILTERED}"
           end.join("&")

data/lib/graph_weaver/internal/headers.rb

@@ -1,6 +1,8 @@
 # typed: true
 # frozen_string_literal: true
 
+require "time" # Time.httpdate, for Retry-After
+
 module GraphWeaver
   module Internal
     # Response headers, as ServerError carries them. HTTP field names are
@@ -42,6 +44,23 @@ module GraphWeaver
         rest.empty? ? value : value&.dig(*rest)
       end
 
+      # Seconds to wait per the server's Retry-After, which is either a delay
+      # in seconds or an HTTP-date. nil when absent or unparseable; a date
+      # already past clamps to 0. See RFC 9110 §10.2.3.
+      #
+      # Here rather than on ServerError because a rate limit reaches a caller
+      # two ways — raised, and returned as the envelope a 4xx/5xx WITH a
+      # GraphQL errors body makes — and both have to read the one rule.
+      def retry_after
+        value = self["retry-after"]&.strip
+        return if value.nil? || value.empty?
+        return value.to_f if value.match?(/\A\d+(\.\d+)?\z/)
+
+        [Time.httpdate(value) - Time.now, 0.0].max
+      rescue ArgumentError
+        nil
+      end
+
       def key?(name) = super(Headers.fold(name))
       alias_method :has_key?, :key?
       alias_method :include?, :key?

data/lib/graph_weaver/internal/test_clients.rb

@@ -8,13 +8,12 @@ module GraphWeaver
     # a `graphql_*` helper writes to.
     #
     # A tag used to work by swapping GraphWeaver.client, which is the LAST
-    # place a module looks: one generated with `client:` reads its baked
-    # DEFAULT_CLIENT first and never got there, so the tag quietly didn't
-    # apply. The mode installs itself here instead, and QueryModule asks
-    # before it reads that constant — so a tag reaches every module the
-    # example runs, bound or not.
+    # place a module looks: one whose graph names a client of its own reads
+    # that first and never got there, so the tag quietly didn't apply. The
+    # mode installs itself here instead, and QueryModule asks before it reads
+    # the graph — so a tag reaches every module the example runs.
     #
-    # Keyed by the graph a module was generated from (its baked GRAPH), since
+    # Keyed by the graph a module was generated from (its GRAPH), since
     # the honest answer varies: :fake for a billing module has to fabricate
     # billing's shapes, not the other schema's. A helper names its graphs the
     # same way and lands in the same table, so what an example says applies to
@@ -254,11 +253,8 @@ module GraphWeaver
         # generated before its graph was declared, or by an older release —
         # and guessing would fake one schema's shapes at another's module.
         def graph_for!(mod)
-          graphs = GraphWeaver.graphs
-          return graphs.first if graphs.one?
-
           name = mod.const_defined?(:GRAPH, false) ? mod.const_get(:GRAPH) : nil
-          found = graphs.find { |graph| graph.name == name }
+          found = Util.graph_named(name)
           return found if found
 
           # Two doors produce a module, so the fix has two spellings: a file
@@ -268,7 +264,7 @@ module GraphWeaver
           raise GraphWeaver::Error, "#{mod} doesn't say which of this app's graphs " \
             "(#{declared_names}) it was generated from, so #{@mode.inspect} has nothing to run " \
             "it against — regenerate it (rake graph_weaver:generate), or, if it came from " \
-            "GraphWeaver.parse, say which there (graph: #{graphs.first.name.inspect})."
+            "GraphWeaver.parse, say which there (graph: #{GraphWeaver.graphs.first.name.inspect})."
         end
       end
     end

data/lib/graph_weaver/internal.rb

@@ -52,19 +52,29 @@ module GraphWeaver
 
         # The module a .graphql file generates, and the basename of the file
         # it generates into: the camelized file name plus the operation's own
-        # word.
+        # word. Every run of non-alphanumerics in the name is a word boundary,
+        # and a trailing extension naming the document's own operation kind is
+        # dropped rather than doubled.
         #
         #      person.graphql          => PersonQuery       (person_query.rb)
         #      save_list_entry.graphql => SaveListEntryMutation
         #                                 (save_list_entry_mutation.rb)
+        #      get-hello.graphql       => GetHelloQuery     (get_hello_query.rb)
+        #      hello.query.graphql     => HelloQuery        (hello_query.rb)
         #
         # Every naming site goes through here — generate!, parse(path), and
         # load_queries! — so the constant a file produces is the same one
         # whichever door you came in by, and the file it lands in matches it.
         def generated_names(path, source)
-          base = File.basename(path, ".*")
-          suffix = operation_suffix(source)
-          ["#{Inflect.camelize(base)}#{suffix}", "#{base}_#{suffix.downcase}.rb"]
+          kind = operation_kind(source)
+          base = strip_kind_extension(File.basename(path, ".*"), kind, path)
+          stem = base.gsub(/[^A-Za-z0-9]+/, "_")
+          suffix = (kind == "mutation") ? "Mutation" : "Query"
+          name = Inflect.camelize(stem)
+          # all punctuation camelizes to nothing, which would leave the suffix
+          # standing alone as the whole name — keep the base so it stays refusable
+          name = base if name.empty?
+          ["#{name}#{suffix}", "#{stem}_#{suffix.downcase}.rb"]
         end
 
         # just the module name — see generated_names
@@ -131,6 +141,21 @@ module GraphWeaver
           schema && GraphWeaver.graphs.find { |candidate| candidate.live_schema.equal?(schema) }
         end
 
+        # The declared graph `name` names, or nil — how a generated module
+        # finds the graph whose client it runs against, and whose schema a
+        # test mode fabricates from.
+        #
+        # One graph in an app is the answer whatever a module calls it: a
+        # module generated before its graph was named, or by an older release,
+        # still belongs to the only graph there is. With several, guessing
+        # would send one schema's query to another's endpoint.
+        def graph_named(name)
+          graphs = GraphWeaver.graphs
+          return graphs.first if graphs.one?
+
+          graphs.find { |graph| graph.name == name }
+        end
+
         # Where generated modules are READ from: the configured patterns, plus
         # any graph writing somewhere they don't already cover. generated_paths'
         # default glob (app/graphql/*/generated) covers the conventional layout,
@@ -240,13 +265,36 @@ module GraphWeaver
           source
         end
 
-        # "Mutation" for a mutation document, "Query" for everything else.
-        def operation_suffix(source)
+        # The document's operation kind — "query", "mutation" or
+        # "subscription" — or nil when it holds no operation or won't parse.
+        # The one source of truth for the word a module name ends in AND for
+        # the file-name extension that word makes redundant.
+        def operation_kind(source)
           operation = GraphQL.parse(source).definitions
             .grep(GraphQL::Language::Nodes::OperationDefinition).first
-          (operation&.operation_type == "mutation") ? "Mutation" : "Query"
+          operation && (operation.operation_type || "query") # `{ hello }` is shorthand for a query
         rescue GraphQL::ParseError
-          "Query" # unparseable: codegen brands the real error a moment later
+          nil # unparseable: codegen brands the real error a moment later
+        end
+
+        # GraphQL's operation kinds, as a file name spells them. Apollo, Relay
+        # and GitLab's frontend all name a query file for its operation, so
+        # `blob_content.query.graphql` says in the extension exactly what the
+        # module's own suffix says — drop it rather than emit BlobContentQueryQuery.
+        # `_query` inside a snake_case name is a word OF the name, not this, so
+        # nothing that generates today is renamed.
+        OPERATION_EXTENSION = /\.(query|mutation|subscription)\z/i
+        private_constant :OPERATION_EXTENSION
+
+        def strip_kind_extension(base, kind, path)
+          declared = base[OPERATION_EXTENSION, 1]&.downcase
+          stem = declared && base[0...-(declared.length + 1)]
+          return base if stem.nil? || stem.empty?
+          return stem if kind.nil? || kind == declared
+
+          raise GraphWeaver::Error, "#{relative(path)}: the file name ends .#{declared}, but the " \
+            "document defines a #{kind} — rename it #{stem}.#{kind}#{File.extname(path)} " \
+            "or drop the .#{declared}"
         end
       end
     end
@@ -350,7 +398,8 @@ module GraphWeaver
       # every request, and the only way to be wrong (a field literally named
       # `mutation` opening a line) errs toward not retrying.
       MUTATION_PATTERN = /^[ \t]*mutation\b/
-      private_constant :MUTATION_PATTERN
+      SUBSCRIPTION_PATTERN = /^[ \t]*subscription\b/
+      private_constant :MUTATION_PATTERN, :SUBSCRIPTION_PATTERN
 
       REQUEST_MUTEX = Mutex.new
       private_constant :REQUEST_MUTEX
@@ -365,16 +414,35 @@ module GraphWeaver
 
         def mutation?(query) = MUTATION_PATTERN.match?(query)
 
+        # What this document runs, for the instrumentation payload — :query
+        # for the shorthand `{ ... }` document too, which is what it is.
+        # Built on mutation? rather than beside it, so an APM's write-failure
+        # rate and the decision not to retry can't come to disagree.
+        def kind(query)
+          return :mutation if mutation?(query)
+
+          SUBSCRIPTION_PATTERN.match?(query) ? :subscription : :query
+        end
+
         # one error in the shape a GraphQL response carries them
         def graphql_error(message, code)
           { "message" => message, "extensions" => { "code" => code } }
         end
 
-        # "[req 3 FilteredPokemon]" — a per-process request id plus the
-        # operation name, when there is one
+        # "[req 4123-3 FilteredPokemon]" — the pid, this process's own
+        # request count, and the operation name when there is one.
+        #
+        # Both halves, because a Puma cluster forks: the counter is inherited
+        # with everything else, so without the reset every worker continues
+        # the master's sequence, and without the pid two workers' "[req 3]"
+        # are two unrelated requests in one aggregated log.
         def log_tag(operation_name = nil)
-          id = REQUEST_MUTEX.synchronize { @request_count = (@request_count || 0) + 1 }
-          "[req #{id}#{" #{operation_name}" if operation_name}]"
+          pid = Process.pid
+          id = REQUEST_MUTEX.synchronize do
+            @request_pid, @request_count = pid, 0 unless @request_pid == pid
+            @request_count += 1
+          end
+          "[req #{pid}-#{id}#{" #{operation_name}" if operation_name}]"
         end
 
         def truncate_for_log(query)

data/lib/graph_weaver/log_subscriber.rb

@@ -1,6 +1,12 @@
 # typed: ignore — ActiveSupport::LogSubscriber, which sorbet can't resolve here
 # frozen_string_literal: true
 
+# The superclass, so this file stands alone: requiring it by hand is the
+# documented way to subscribe outside Rails, and there is no railtie out there
+# to have loaded ActiveSupport first. Skipped when the constant already
+# exists, which is how a stand-in can take its place.
+require "active_support/log_subscriber" unless defined?(ActiveSupport::LogSubscriber)
+
 module GraphWeaver
   # One line per GraphQL operation in a Rails log, the shape ActiveRecord
   # uses for a query:
@@ -54,11 +60,13 @@ module GraphWeaver
       payload[:graph] ? "#{payload[:graph]}/#{operation}" : operation
     end
 
-    # status, then whatever narrows it: the error class, the code an alert
+    # status, then whatever narrows it: the error class, the reason an alert
     # groups by, and which attempt this was when a Retry is in the stack.
     def outcome(payload)
       parts = [payload[:status], payload[:error]]
-      parts << "[#{payload[:code]}]" if payload[:code]
+      # the GraphQL code, or the HTTP status where the request never got one
+      reason = payload[:code] || (payload[:http_status] if payload[:status] == :failed)
+      parts << "[#{reason}]" if reason
       parts << "(retry #{payload[:retries]})" if payload[:retries].to_i.positive?
       parts.compact.join(" ")
     end

data/lib/graph_weaver/logging.rb

@@ -53,7 +53,7 @@ module GraphWeaver
     #
     # It must call the block and return its value. The only event today is
     # EXECUTE_EVENT; its payload is the contract in docs/logging.md —
-    # :operation, :client, :status, :duration_ms, :graph always;
+    # :operation, :client, :kind, :status, :duration_ms, :graph always;
     # :url/:http_status over the wire, :schema in-process, :error/:code on a
     # failure, :retries when a Retry wrapped it. Never the query text or the
     # variables: the payload fans out to subscribers that know none of the
@@ -77,6 +77,15 @@ module GraphWeaver
           !key.nil? && Log.filter_variables({ key.to_s => nil })[key.to_s] == FILTERED
         end
 
+        # True when this key names a credential — asked of a url's query
+        # parameters, which are scrubbed whatever the app's logging appetite.
+        # filter_parameters is a knob about log verbosity; emptying it must
+        # not un-scrub a token in an endpoint, any more than it un-scrubs the
+        # url's userinfo. The app's list widens this; it can't narrow it.
+        def credential?(key)
+          filtered?(key) || Log.filtered?(key, GraphWeaver::DEFAULT_FILTER_PARAMETERS)
+        end
+
         # `detail` unless the key is filtered — free text a coercer or sorbet
         # wrote can spell a value any way, so for a filtered key none of it
         # survives, not the parts that would have been safe.
@@ -94,12 +103,18 @@ module GraphWeaver
         # optional because a coercer refusing a value hasn't been told one.
         def shown(raw, key = nil) = filtered?(key) ? FILTERED : cap(value(key, raw).inspect)
 
+        # A short server-chosen string the library republishes inside its own
+        # text — the APM's :code, the [CODE] in the one line info writes, a
+        # redirect's destination. Control characters are stripped because it
+        # lands where the log's own framing lives: a newline in
+        # extensions.code forges a second, complete-looking line.
+        def tag(value) = value.is_a?(String) ? cap(value.gsub(/[[:cntrl:]]+/, " ")) : value
+
         # Text the library didn't author — a value a caller sent, a sentence a
         # server wrote — cut to what an error may carry. The number lives on
         # InputError, which is the class that documents it and the one every
         # capped string reaches.
-        def cap(text)
-          limit = GraphWeaver::InputError::VALUE_LIMIT
+        def cap(text, limit = GraphWeaver::InputError::VALUE_LIMIT)
           return text if text.bytesize <= limit
 
           # byteslice can land mid-character; scrub drops the partial tail
@@ -183,13 +198,15 @@ module GraphWeaver
                 payload[:status] = :ok
               else
                 payload[:status] = :errors
-                payload[:code] = errors.grep(Hash).filter_map { |e| GraphWeaver::GraphQLError.from_h(e).code }.first
+                code = errors.grep(Hash).filter_map { |e| GraphWeaver::GraphQLError.from_h(e).code }.first
+                payload[:code] = Redact.tag(code)
               end
               result
             rescue => e
               payload[:error] = e.class.name
-              # the one key an alert groups by, whichever kind of failure it was
-              payload[:code] = e.status if e.is_a?(GraphWeaver::ServerError)
+              # :code stays the GraphQL error code and nothing else — it used
+              # to hold a ServerError's status here, so one tag carried two
+              # dimensions ("THROTTLED" and 429). The number is :http_status.
               raise
             ensure
               payload[:duration_ms] = ((Process.clock_gettime(Process::CLOCK_MONOTONIC) - start) * 1000).round(2)
@@ -249,6 +266,16 @@ module GraphWeaver
           filters.nil? ? variables : filters.filter(variables)
         end
 
+        # Whether a key matches one of `filters` — the same matching the
+        # variables line uses, asked about a list other than the app's so
+        # Redact.credential? can hold url parameters to the default names.
+        def filtered?(key, filters)
+          name = key.to_s
+          filters.any? do |filter|
+            filter.is_a?(Regexp) ? name.match?(filter) : name.downcase.include?(filter.to_s.downcase)
+          end
+        end
+
         private
 
         # The GraphQL errors a response carries, whatever answered it — a
@@ -269,13 +296,6 @@ module GraphWeaver
           else value
           end
         end
-
-        def filtered?(key, filters)
-          name = key.to_s
-          filters.any? do |filter|
-            filter.is_a?(Regexp) ? name.match?(filter) : name.downcase.include?(filter.to_s.downcase)
-          end
-        end
       end
     end
   end