graph_weaver 0.0.1 → 0.2.0

data/lib/graph_weaver/errors.rb

@@ -0,0 +1,322 @@
+# typed: true
+# frozen_string_literal: true
+
+require "sorbet-runtime"
+require_relative "inflect"
+require_relative "logging"
+
+module GraphWeaver
+  # Base for every error GraphWeaver raises — rescue this to catch them
+  # all. #message is the human-friendly side; #to_h is the machine side —
+  # a JSON-ready Hash (string keys) for logging, agents, or surfacing
+  # structured failures to users. One subclass per failure site —
+  # {TransportError} (never reached the server), {ServerError} (non-2xx),
+  # {QueryError} (GraphQL-level errors), {TypeError} (response wouldn't
+  # cast), {ValidationError} (build time) — each merging its specifics
+  # into #to_h.
+  class Error < StandardError
+    # every GraphWeaver error surfaces on the logger too (see
+    # GraphWeaver.logger) — construction here means a raise
+    def initialize(*args)
+      super
+      GraphWeaver.log(:warn) { "#{self.class.name}: #{message}" }
+    end
+
+    def to_h
+      { "error" => self.class.name, "message" => message }
+    end
+  end
+
+  # The request never reached the server: connection refused, DNS failure,
+  # TLS handshake, timeout. The original exception is preserved as #cause.
+  # Generally retriable.
+  class TransportError < Error
+    def to_h
+      super.merge("cause" => cause&.class&.name)
+    end
+  end
+
+  class << self
+    # The exception classes the bundled transports reclassify as
+    # TransportError — network-level failures where the request never
+    # reached the server. A mutable Set: each transport contributes its own
+    # on load (net/http adds Timeout/SSL, Faraday adds its ConnectionFailed,
+    # …), and you can add more so they get the same handling:
+    #
+    #      GraphWeaver.transport_errors << MyPool::TimeoutError
+    #      GraphWeaver.register_transport_error(Adapter::ResetError)
+    #
+    # SystemCallError covers every Errno::* (connection refused/reset, host
+    # unreachable); SocketError covers DNS.
+    def transport_errors
+      @transport_errors ||= Set[SocketError, SystemCallError, IOError]
+    end
+
+    # Add one or more exception classes to the transport-error set.
+    def register_transport_error(*classes)
+      transport_errors.merge(classes)
+      classes
+    end
+  end
+
+  # The request reached the server but it returned a non-2xx status — a 500
+  # that exploded, a 502 from a proxy, a 401, etc. Distinct from a GraphQL
+  # error: we got an HTTP response, it just wasn't success.
+  class ServerError < Error
+    attr_reader :status, :body
+
+    def initialize(status:, body: nil)
+      @status = status
+      @body = body
+      snippet = body.to_s.empty? ? "" : ": #{body.to_s[0, 500]}"
+      super("HTTP #{status}#{snippet}")
+    end
+
+    def to_h
+      super.merge("status" => status)
+    end
+  end
+
+  # One entry from a GraphQL response's top-level `errors` array. A value
+  # object (not raised) — the response envelope and QueryError carry these.
+  # Match on #code (extensions["code"]) rather than the message string.
+  class GraphQLError
+    attr_reader :message, :locations, :path, :extensions
+
+    def initialize(message:, locations: [], path: nil, extensions: {}, type: nil)
+      @message = message
+      @locations = locations
+      @path = path
+      @extensions = extensions
+      @error_type = type
+    end
+
+    def self.from_h(hash)
+      new(
+        message: hash["message"] || "(no message)",
+        locations: hash["locations"] || [],
+        path: hash["path"],
+        extensions: hash["extensions"] || {},
+        type: hash["type"],
+      )
+    end
+
+    # The machine-readable error code, e.g. "THROTTLED" — the thing to
+    # branch on. Read from extensions.code (the Apollo/spec-adjacent
+    # convention) or a top-level "type" (GitHub's dialect: NOT_FOUND,
+    # FORBIDDEN). nil when the server sent neither.
+    def code
+      extensions["code"] || @error_type
+    end
+
+    # Message shapes servers use when they reject the *shape* of a query
+    # (unknown field/type/argument). Heuristic by necessity: only Apollo
+    # sets a standard code (GRAPHQL_VALIDATION_FAILED); graphql-ruby and
+    # GitHub speak in messages.
+    VALIDATION_MESSAGE = /doesn't exist|Cannot query field|Unknown (field|type|argument)|isn't defined|undefined (field|type)/i
+
+    # True when this error looks like the server rejected the query's
+    # shape — for a generated module that usually means the schema
+    # changed after generation.
+    def validation?
+      code == "GRAPHQL_VALIDATION_FAILED" || VALIDATION_MESSAGE.match?(message)
+    end
+
+    # The field the error points at, as a stable dotted path with list
+    # indices stripped — ["people", 3, "email"] => "people.email". The
+    # parseable key for grouping/reporting (the raw #path keeps indices).
+    # nil for global errors with no path.
+    def field
+      return unless path
+
+      named = path.reject { |seg| seg.is_a?(Integer) || seg.to_s.match?(/\A\d+\z/) }
+      named.join(".") unless named.empty?
+    end
+
+    def to_s
+      loc = locations&.first
+      at = loc ? " at #{loc["line"]}:#{loc["column"]}" : ""
+      where = path ? " (path: #{path.join(".")})" : ""
+      tag = code ? " [#{code}]" : ""
+      "#{message}#{at}#{where}#{tag}"
+    end
+
+    # JSON-ready: the problematic field (both forms — #field for grouping,
+    # #path with indices for exact location), the machine code, and the
+    # server's full extensions.
+    def to_h
+      {
+        "message" => message,
+        "code" => code,
+        "field" => field,
+        "path" => path,
+        "locations" => locations,
+        "extensions" => extensions,
+        "validation" => validation?,
+      }
+    end
+  end
+
+  # Shared filtering over a collection of GraphQLErrors, for surfacing
+  # field-level failures programmatically. Host must define #errors.
+  module ErrorFiltering
+    include Kernel # for sorbet: hosts are Objects
+
+    # the host's interface, overridden by its attr_readers
+    def errors
+      raise NotImplementedError, "#{self.class} must define #errors"
+    end
+
+    def data
+      raise NotImplementedError, "#{self.class} must define #data"
+    end
+
+    # Errors touching a field path — "user.email" or ["user", "email"];
+    # prefix match, so deeper errors count too. List indices appear as
+    # path segments ("people.0.email").
+    def errors_at(path)
+      want = (path.is_a?(String) ? path.split(".") : path).map(&:to_s)
+      errors.select { |error| error.path && error.path.map(&:to_s).first(want.size) == want }
+    end
+
+    # True when any error looks like the server rejected the query's
+    # shape — the schema has likely changed since the module was
+    # generated. Refresh the schema dump and regenerate (rake
+    # graph_weaver:schema:refresh && rake graph_weaver:generate).
+    def schema_stale?
+      errors.any?(&:validation?)
+    end
+
+    # Errors grouped by the field they point at (index-stripped dotted
+    # path; nil key for global errors) — iterate with each_error:
+    #
+    #      response.each_error do |field, errors|
+    #        form.add_error(field, errors.map(&:message))
+    #      end
+    def errors_by_field
+      errors.group_by(&:field)
+    end
+
+    def each_error(&block)
+      errors_by_field.each(&block)
+    end
+
+    # The id of the record an error points into, resolved by walking the
+    # error's path through the (partial) typed data: an error at
+    # ["people", 3, "email"] resolves to people[3].id. nil when the data
+    # is missing, the path doesn't walk, or the record has no id field.
+    def entity_id(error)
+      # untyped by nature: the walk traverses whatever structs this query
+      # generated, reassigning across types at each step
+      node = T.let(data, T.untyped)
+      return unless node && error.path
+
+      error.path[0..-2].each do |segment|
+        node = if segment.is_a?(Integer) || segment.to_s.match?(/\A\d+\z/)
+          node.is_a?(Array) ? node[segment.to_i] : nil
+        else
+          prop = GraphWeaver::Inflect.underscore(segment.to_s).to_sym
+          node.respond_to?(prop) ? node.public_send(prop) : nil
+        end
+        return if node.nil?
+      end
+
+      node.respond_to?(:id) ? node.id : nil
+    end
+
+    # The user-facing rollup: errors keyed by field, with the ids of the
+    # actual records that failed inlined — "the 3 in people.3.email is
+    # useless to a user; people.email plus which people is the answer".
+    #
+    #      { "people.email" => { "messages" => [...], "codes" => [...],
+    #        "entity_ids" => ["7", "9"], "errors" => [full to_h...] } }
+    def report
+      errors_by_field.to_h do |field, field_errors|
+        [field, {
+          "messages" => field_errors.map(&:message),
+          "codes" => field_errors.filter_map(&:code).uniq,
+          "entity_ids" => field_errors.filter_map { |e| entity_id(e) }.uniq,
+          "errors" => field_errors.map(&:to_h),
+        }]
+      end
+    end
+  end
+
+  # Raised when a GraphQL response carried top-level errors and the caller
+  # demanded data (Response#data!, or the one-shot GraphWeaver.execute).
+  # Carries the structured errors, any partial data, and top-level
+  # extensions (cost/throttle metadata).
+  class QueryError < Error
+    include ErrorFiltering
+
+    attr_reader :errors, :data, :extensions
+
+    def initialize(errors, data: nil, extensions: {})
+      @errors = errors
+      @data = data
+      @extensions = extensions
+      super(summary)
+    end
+
+    # All non-nil error codes — handy for `codes.include?("THROTTLED")`.
+    def codes
+      errors.map(&:code).compact
+    end
+
+    # The machine side: every error with its path/code/extensions, plus
+    # the drift verdict — nest this straight into a JSON response.
+    def to_h
+      super.merge(
+        "schema_stale" => schema_stale?,
+        "codes" => codes,
+        "errors" => errors.map(&:to_h),
+        "extensions" => extensions,
+      )
+    end
+
+    private
+
+    def summary
+      first = errors.first
+      more = errors.size > 1 ? " (and #{errors.size - 1} more)" : ""
+      drift = schema_stale? ? " — the server rejected the query shape: the schema may have changed since generation; refresh the schema dump and regenerate (rake graph_weaver:schema:refresh && rake graph_weaver:generate)" : ""
+      "GraphQL query failed: #{first}#{more}#{drift}"
+    end
+  end
+
+  # Raised when a response can't be cast into the generated structs — the
+  # wire data disagreed with the types the schema promised at generation
+  # time (a nil where non-null was declared, a malformed scalar, an
+  # unknown enum value). #struct names the generated type that failed;
+  # #cause carries the original TypeError/KeyError with the offending
+  # prop in its message.
+  class TypeError < Error
+    attr_reader :struct
+
+    def initialize(struct:, error: nil, message: nil)
+      @struct = struct
+      super("failed to cast response into #{struct}: #{message || error&.message}")
+    end
+
+    def to_h
+      super.merge("struct" => struct.to_s, "cause" => cause&.message)
+    end
+  end
+
+  # Build-time: the query didn't validate against the schema. Carries the
+  # structured validation errors (message + line/column) rather than a
+  # joined string. Under the Error umbrella like everything else raised
+  # here (through 0.1.0 it was an ArgumentError instead).
+  class ValidationError < Error
+    attr_reader :errors
+
+    def initialize(errors)
+      @errors = errors
+      super("invalid query: #{errors.map { |e| e[:message] }.join("; ")}")
+    end
+
+    def to_h
+      super.merge("errors" => errors.map { |e| e.transform_keys(&:to_s) })
+    end
+  end
+end

data/lib/graph_weaver/hints.rb

@@ -0,0 +1,63 @@
+# typed: true
+# frozen_string_literal: true
+
+require "sorbet-runtime"
+
+require_relative "inflect"
+
+module GraphWeaver
+  # Included in generated response structs. GraphQL's camelCase fields
+  # become snake_case props, and reaching for the wire name is a classic
+  # stumble — result.nameWithOwner instead of result.name_with_owner.
+  # Catch the miss and point at the prop that does exist ("use ..." when
+  # the mapping is exact, "did you mean ...?" for a near-miss typo).
+  # (Typed call sites get this hint earlier, from srb tc.)
+  module Hints
+    include Kernel # for sorbet: hosts are Objects
+
+    # Guard for generated input-struct .coerce: a hash key that matches
+    # no prop raises (spellchecked) instead of silently dropping — a
+    # typo'd filter key must not become "match everything" on the wire.
+    def self.validate_keys!(struct, hash)
+      known = struct.props.keys.map(&:to_s)
+      unknown = hash.keys.map(&:to_s) - known
+      return if unknown.empty?
+
+      hints = unknown.map do |key|
+        prop = GraphWeaver::Inflect.underscore(key)
+        suggestion = if known.include?(prop)
+          prop # a wire-cased key — the exact snake_case prop exists
+        elsif defined?(DidYouMean::SpellChecker)
+          DidYouMean::SpellChecker.new(dictionary: known).correct(prop).first
+        end
+        suggestion ? "#{key} (did you mean '#{suggestion}'?)" : key
+      end
+      raise ArgumentError, "unknown key(s) for #{struct}: #{hints.join(", ")}"
+    end
+
+    def method_missing(name, *args, &block)
+      if args.empty? && (hint = prop_hint(name.to_s))
+        raise NoMethodError, "undefined method '#{name}' for #{self.class} — #{hint}"
+      end
+
+      super
+    end
+
+    private
+
+    def prop_hint(name)
+      prop = GraphWeaver::Inflect.underscore(name)
+      if prop != name && respond_to?(prop)
+        return "GraphQL fields generate snake_case props; use '#{prop}'"
+      end
+
+      return unless defined?(DidYouMean::SpellChecker)
+
+      # a guess, not a mapping — spellcheck the (underscored) miss
+      # against the props that exist, so typos in either casing land
+      props = T.unsafe(self.class).props.keys.map(&:to_s)
+      suggestion = DidYouMean::SpellChecker.new(dictionary: props).correct(prop).first
+      "did you mean '#{suggestion}'?" if suggestion
+    end
+  end
+end

data/lib/graph_weaver/inflect.rb

@@ -0,0 +1,19 @@
+# typed: true
+# frozen_string_literal: true
+
+module GraphWeaver
+  # GraphQL names are plain camelCase/SCREAMING_SNAKE — no acronym edge
+  # cases, so minimal inflection beats an activesupport dependency
+  module Inflect
+    module_function
+
+    def underscore(name)
+      name.gsub(/([a-z\d])([A-Z])/, '\1_\2').downcase
+    end
+
+    def camelize(name)
+      # reject: leading underscores split into empty parts (_Service, _and)
+      name.split("_").reject(&:empty?).map { |part| "#{part[0].upcase}#{part[1..]}" }.join
+    end
+  end
+end

data/lib/graph_weaver/logging.rb

@@ -0,0 +1,41 @@
+# typed: true
+# frozen_string_literal: true
+
+module GraphWeaver
+  class << self
+    # Where GraphWeaver narrates what it's doing — anything
+    # stdlib-Logger-compatible (Logger, Rails.logger, semantic_logger...).
+    # Silent by default; Rails apps get Rails.logger wired by the railtie.
+    #
+    #      GraphWeaver.logger = Logger.new($stdout, level: Logger::INFO)
+    #
+    # What logs where:
+    #   debug — full queries + variables on the wire, responses
+    #           (status/bytes/ms), connection lifecycle, parsed modules
+    #   info  — schema introspection and cache decisions, generated files
+    #           written, query modules loaded
+    #   warn  — every GraphWeaver error raised
+    #
+    # Queries, variables, and responses appear at debug ONLY — they can
+    # carry PII. Auth headers never log.
+    attr_accessor :logger
+
+    # Internal: level-gated and lazy — the block only runs when a logger
+    # is listening. Messages carry "graph_weaver" as progname.
+    def log(level, &block)
+      logger&.public_send(level, "graph_weaver", &block)
+    end
+
+    # Internal: run the block, logging "<label> (Nms)" at level — timing
+    # skipped entirely when no logger is set. Returns the block's value.
+    def log_timed(level, label)
+      return yield unless logger
+
+      start = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+      result = yield
+      ms = ((Process.clock_gettime(Process::CLOCK_MONOTONIC) - start) * 1000).round
+      log(level) { "#{label} (#{ms}ms)" }
+      result
+    end
+  end
+end

data/lib/graph_weaver/railtie.rb

@@ -0,0 +1,29 @@
+# typed: ignore — Rails::Railtie DSL
+# frozen_string_literal: true
+
+# Rails wiring, so the conventional layout needs no ceremony:
+#
+# - rake tasks: Rails.application.load_tasks collects every Railtie's
+#   rake_tasks block, so graph_weaver:* tasks appear with no Rakefile
+#   edit. (Outside Rails there is no task-discovery hook — add
+#   `require "graph_weaver/tasks"` to your Rakefile.)
+# - generated modules: required at boot when generated_path exists,
+#   after config/initializers (registrations and GraphWeaver.client=
+#   run first — block-built type helpers must exist before the files
+#   that include them load). load_generated! stays idempotent, so
+#   calling it yourself too is harmless.
+class GraphWeaver::Railtie < Rails::Railtie
+  rake_tasks do
+    require "graph_weaver/tasks"
+  end
+
+  # Rails.logger, unless the app already chose one (set
+  # GraphWeaver.logger = nil in an initializer to silence)
+  initializer "graph_weaver.logger" do
+    GraphWeaver.logger = Rails.logger if GraphWeaver.logger.nil?
+  end
+
+  initializer "graph_weaver.load_generated", after: :load_config_initializers do
+    GraphWeaver.load_generated! if Dir.exist?(GraphWeaver.generated_path)
+  end
+end

data/lib/graph_weaver/response.rb

@@ -0,0 +1,55 @@
+# typed: strict
+# frozen_string_literal: true
+
+require "sorbet-runtime"
+
+require_relative "errors"
+
+module GraphWeaver
+  # The envelope every generated #execute returns: the typed data (nil on a
+  # total failure), the top-level GraphQL errors, and top-level extensions
+  # (cost/throttle metadata). Generic over the query's Result type so
+  # response.data stays fully typed — the generated code instantiates it as
+  # GraphWeaver::Response[SomeQuery::Result]. #data! is the strict accessor:
+  # the result, or a raised QueryError.
+  class Response
+    extend T::Sig
+    extend T::Generic
+    include ErrorFiltering
+
+    Data = type_member
+
+    sig { returns(T.nilable(Data)) }
+    attr_reader :data
+
+    sig { returns(T::Array[GraphWeaver::GraphQLError]) }
+    attr_reader :errors
+
+    sig { returns(T::Hash[String, T.untyped]) }
+    attr_reader :extensions
+
+    sig do
+      params(
+        data: T.nilable(Data),
+        errors: T::Array[GraphWeaver::GraphQLError],
+        extensions: T::Hash[String, T.untyped],
+      ).void
+    end
+    def initialize(data:, errors: [], extensions: {})
+      @data = data
+      @errors = errors
+      @extensions = extensions
+    end
+
+    sig { returns(T::Boolean) }
+    def errors? = !errors.empty?
+
+    # The typed result, or raise QueryError if the response carried top-level
+    # errors (partial data and extensions ride along on the error).
+    sig { returns(Data) }
+    def data!
+      raise GraphWeaver::QueryError.new(errors, data: data, extensions: extensions) unless errors.empty?
+      T.must(data)
+    end
+  end
+end

data/lib/graph_weaver/retry.rb

@@ -0,0 +1,97 @@
+# typed: true
+# frozen_string_literal: true
+
+require_relative "errors"
+
+# Wraps any client/transport with configurable retries — it satisfies
+# the same execute contract, so it layers over HTTP, Faraday, or
+# anything else:
+#
+#      client = GraphWeaver::Retry.new(
+#        GraphWeaver::Transport::HTTP.new(url),
+#        tries: 5,                        # total attempts, first included
+#        on: [GraphWeaver::TransportError, GraphWeaver::ServerError],
+#        backoff: :exponential,           # or :linear, or ->(attempt) { seconds }
+#        base: 0.5, max: 30,              # seconds; delays clamp at max:
+#        jitter: true,                    # randomize each delay by 50-100%
+#        retry_codes: ["THROTTLED"],      # also retry GraphQL errors by code
+#      )
+#
+# What retries, by default:
+#   - TransportError: always (the request never arrived)
+#   - ServerError: only 5xx — a 4xx is a bug in the request, retrying
+#     won't fix it. Override with retry_if: ->(error) { ... }
+#   - responses whose GraphQL error codes intersect retry_codes: (off by
+#     default — pass the codes your API uses for transient failures)
+#
+# Exhausting tries re-raises the last error (or returns the last
+# code-matched response).
+class GraphWeaver::Retry
+  BACKOFFS = {
+    exponential: ->(base, attempt) { base * (2**(attempt - 1)) },
+    linear: ->(base, attempt) { base * attempt },
+  }.freeze
+
+  # retry 5xx, not 4xx; everything else listed in on: retries
+  DEFAULT_RETRY_IF = lambda do |error|
+    !error.is_a?(GraphWeaver::ServerError) || error.status >= 500
+  end
+
+  def initialize(client, tries: 3, on: [GraphWeaver::TransportError, GraphWeaver::ServerError],
+    backoff: :exponential, base: 0.5, max: 30, jitter: true, retry_if: DEFAULT_RETRY_IF,
+    retry_codes: [], sleeper: nil)
+    raise ArgumentError, "tries: must be >= 1" unless tries >= 1
+
+    @client = client
+    @tries = tries
+    @on = on
+    @backoff = if backoff.is_a?(Proc)
+      ->(_base, attempt) { backoff.call(attempt) } # custom: ->(attempt) { seconds }
+    else
+      BACKOFFS.fetch(backoff) {
+        raise ArgumentError, "backoff: must be :exponential, :linear, or a Proc, got #{backoff.inspect}"
+      }
+    end
+    @base = base
+    @max = max
+    @jitter = jitter
+    @retry_if = retry_if
+    @retry_codes = retry_codes
+    @sleeper = sleeper || ->(seconds) { sleep(seconds) }
+  end
+
+  # surface the wrapped transport's endpoint (schema-dump provenance)
+  def url
+    @client.url if @client.respond_to?(:url)
+  end
+
+  def execute(query, variables: {})
+    attempt = 0
+
+    loop do
+      attempt += 1
+      begin
+        response = @client.execute(query, variables:)
+        return response unless attempt < @tries && retryable_response?(response)
+      rescue *@on => e
+        raise if attempt >= @tries || !@retry_if.call(e)
+      end
+
+      @sleeper.call(delay(attempt))
+    end
+  end
+
+  private
+
+  def retryable_response?(response)
+    return false if @retry_codes.empty?
+
+    codes = (response.to_h["errors"] || []).filter_map { |error| error.dig("extensions", "code") }
+    codes.intersect?(@retry_codes)
+  end
+
+  def delay(attempt)
+    seconds = [@backoff.call(@base, attempt), @max].min.to_f
+    @jitter ? seconds * (0.5 + rand * 0.5) : seconds
+  end
+end

data/lib/graph_weaver/rspec.rb

@@ -0,0 +1,59 @@
+# typed: true
+# frozen_string_literal: true
+
+require_relative "testing"
+
+# RSpec integration — require from your spec helper instead of
+# "graph_weaver/testing":
+#
+#      require "graph_weaver/rspec"
+#
+# That one line is the whole setup in a conventional app: the schema
+# auto-locates from the committed dump (GraphWeaver.schema_path) and
+# auto_fake defaults on, so every example runs against a schema-correct
+# fake. Configure to override:
+#
+#      GraphWeaver::Testing.configure do |config|
+#        config.schema = MySchema     # instead of the located dump
+#        config.auto_fake = false     # opt out of per-example fakes
+#      end
+#
+# What it wires up:
+#   - seed: defaults to rspec's --seed, so `rspec --seed 1234` reproduces
+#     fake data along with test order
+#   - auto_fake: when on (and a schema resolves), each example gets a
+#     fresh seeded FakeClient installed as GraphWeaver.client —
+#     generated modules run in test mode with zero per-test setup. The
+#     prior client is restored after each example.
+#
+# note: modules generated with a baked-in client: constant don't consult
+# GraphWeaver.client — generate without client: to make them fakeable.
+module GraphWeaver
+  module Testing
+    module RSpecIntegration
+      def self.install(rspec_config)
+        rspec_config.before(:suite) do
+          config = GraphWeaver::Testing.config
+          config.seed ||= RSpec.configuration.seed
+        end
+
+        rspec_config.before(:each) do
+          config = GraphWeaver::Testing.config
+          next unless config.auto_fake && config.schema
+
+          @__graph_weaver_prior_client = GraphWeaver.client
+          GraphWeaver.client = FakeClient.new(schema: config.schema)
+        end
+
+        rspec_config.after(:each) do
+          config = GraphWeaver::Testing.config
+          next unless config.auto_fake && config.schema
+
+          GraphWeaver.client = @__graph_weaver_prior_client
+        end
+      end
+    end
+  end
+end
+
+RSpec.configure { |config| GraphWeaver::Testing::RSpecIntegration.install(config) } if defined?(RSpec)