graph_weaver 0.1.0 → 0.2.1

data/lib/graph_weaver.rb

@@ -1,35 +1,248 @@
 require "graphql"
 require "sorbet-runtime"
 
+require_relative "graph_weaver/logging"
 require_relative "graph_weaver/errors"
+require_relative "graph_weaver/hints"
+require_relative "graph_weaver/input_struct"
 require_relative "graph_weaver/response"
 require_relative "graph_weaver/inflect"
 require_relative "graph_weaver/codegen"
-require_relative "graph_weaver/http_executor"
+require_relative "graph_weaver/client"
+require_relative "graph_weaver/transport/http"
+require_relative "graph_weaver/retry"
 require_relative "graph_weaver/schema_loader"
 require_relative "graph_weaver/version"
+require_relative "graph_weaver/railtie" if defined?(::Rails::Railtie)
 
 # opt-in extras:
-#   require "graph_weaver/faraday_executor"        # Faraday transport
-#   require "graph_weaver/directive_defaults_patch" # fix graphql-ruby
-#     dropping directive argument defaults when loading SDL (needed for
-#     Apollo supergraph SDL until rmosolgo/graphql-ruby#5659 ships)
+#      require "graph_weaver/transport/faraday"        # Faraday transport
+#      require "graph_weaver/directive_defaults_patch" # fix graphql-ruby
+#        dropping directive argument defaults when loading SDL (needed for
+#        Apollo supergraph SDL until rmosolgo/graphql-ruby#5659 ships)
 module GraphWeaver
   class << self
-    # global default transport; generated modules fall back to this
-    # (override per module with MyQuery.executor=, or per call with
-    # execute(executor:))
-    attr_writer :executor
+    # A client for one GraphQL server — transport, schema, and scoped
+    # scalars in one object (see Client):
+    #
+    #      github = GraphWeaver.new("https://api.github.com/graphql", auth: token, cache: true)
+    #      RepoQuery = github.parse("queries/repo.graphql")
+    #
+    # The first argument is a url or any schema source (a live schema
+    # class, or a path/SDL/introspection dump).
+    def new(source, **options, &middleware)
+      Client.new(source, **options, &middleware)
+    end
+
+    # The app's default client — how generated modules find their server:
+    #
+    #      GraphWeaver.client = GraphWeaver.new(url, auth: token)
+    #
+    # Accepts a Client or anything satisfying the execute contract (a
+    # schema class, a fake — testing's auto_fake swaps one in per
+    # example). Generated modules resolve per call -> per module
+    # (MyQuery.client=) -> baked constant -> here.
+    attr_accessor :client
+
+    # the default client, when one is required
+    def client!
+      @client or raise Error, "no client configured — set GraphWeaver.client= or pass a client"
+    end
+
+    # The transport behind a client-or-transport value: a Client resolves
+    # to its own transport, anything else already speaks execute.
+    # Generated modules call this on every execute, so any slot in the
+    # resolution chain can hold either kind.
+    def resolve_transport(target)
+      target.is_a?(Client) ? target.transport! : target
+    end
+
+    # Conventional locations, factory_bot-style — LISTS, so extra
+    # locations (a test-only dir, an engine's) can be appended and every
+    # loader walks them all:
+    #
+    #      # e.g. in spec/support/graph_weaver.rb
+    #      GraphWeaver.generated_paths << "spec/support/graphql/generated"
+    #      GraphWeaver.queries_paths << "spec/support/graphql/queries"
+    #
+    # The singular accessors read the first entry (the default target
+    # for generate! and the rake tasks); assigning one replaces the list.
+    attr_writer :queries_paths, :generated_paths, :schema_path
+
+    # Entries may be glob patterns — the generated default also matches
+    # per-schema layouts (app/graphql/github/generated). Queries stay
+    # single-schema: load_queries! parses everything against one client.
+    def queries_paths = @queries_paths ||= ["app/graphql/queries"]
+    def generated_paths = @generated_paths ||= ["app/graphql/generated", "app/graphql/*/generated"]
+
+    def queries_path = queries_paths.first
+    def generated_path = generated_paths.first
+
+    def queries_path=(path)
+      @queries_paths = path.nil? ? nil : [path]
+    end
 
-    def executor
-      @executor or raise Error, "no executor configured — set GraphWeaver.executor= or pass executor:"
+    def generated_path=(path)
+      @generated_paths = path.nil? ? nil : [path]
     end
 
+    def schema_path = @schema_path || "app/graphql/schema.json"
+
+    # The shared-inputs module name: set it globally, pass inputs_module:
+    # per generate!, or let it derive from the output path — the
+    # directory above generated/ names the schema in multi-schema
+    # layouts (app/graphql/github/generated => GithubInputs); the
+    # conventional layout (and anything unrecognizable) stays
+    # GraphQLInputs.
+    attr_writer :inputs_module
+
+    def inputs_module(output = generated_path)
+      return @inputs_module if @inputs_module
+
+      segments = File.expand_path(output.to_s).split(File::SEPARATOR)
+      segments.pop if segments.last == "generated"
+      parent = segments.last.to_s
+      if parent.match?(/\A[a-zA-Z]\w*\z/) && !%w[graphql app lib spec support test].include?(parent)
+        "#{Inflect.camelize(parent)}Inputs"
+      else
+        "GraphQLInputs"
+      end
+    end
+
+    # Generate every .graphql query in a directory into checked-in Ruby
+    # files. Paths default to the conventions above; schema: defaults to
+    # the dump at schema_path (any supported extension):
+    #
+    #      GraphWeaver.generate!   # queries_path -> generated_path
+    #
+    # person.graphql => person_query.rb defining PersonQuery. Returns the
+    # written paths. Pair with a freshness spec (docs/generated_modules.md).
+    def generate!(schema: nil, queries: queries_path, output: generated_path, client: nil,
+      shared_inputs: true, inputs_module: nil)
+      schema ||= locate_schema!
+      inputs_module ||= self.inputs_module(output)
+
+      plan = generation_plan(queries:, schema:, client:, shared_inputs:, inputs_module:)
+      written = plan.map do |filename, source|
+        target = File.join(output, filename)
+        FileUtils.mkdir_p(File.dirname(target))
+        File.write(target, source)
+        log(:info) { "generated #{target}" }
+        target
+      end
+
+      # a type dropped from the schema must not linger as a stale file —
+      # inputs/ is wholly generated, so pruning is safe
+      (Dir[File.join(output, "inputs", "*.rb")] - written).each do |orphan|
+        File.delete(orphan)
+        log(:info) { "pruned #{orphan}" }
+      end
+
+      written
+    end
+
+    # The freshness guard: raise unless every generated file matches what
+    # the current schema + queries + scalar registrations would produce.
+    # One line in a spec, or `rake graph_weaver:verify` in CI:
+    #
+    #      it "generated queries are current" do
+    #        GraphWeaver.verify_generated!
+    #      end
+    def verify_generated!(schema: nil, queries: queries_path, output: generated_path, client: nil,
+      shared_inputs: true, inputs_module: nil)
+      schema ||= locate_schema!
+      inputs_module ||= self.inputs_module(output)
+      plan = generation_plan(queries:, schema:, client:, shared_inputs:, inputs_module:)
+      stale = plan.filter_map do |filename, source|
+        target = File.join(output, filename)
+        target unless File.exist?(target) && File.read(target) == source
+      end
+      # strays: a type file the current schema no longer produces
+      stale += Dir[File.join(output, "inputs", "*.rb")] - plan.map { |f, _| File.join(output, f) }
+
+      unless stale.empty?
+        raise Error, "stale generated queries — regenerate (rake graph_weaver:generate): #{stale.join(", ")}"
+      end
+
+      true
+    end
+
+    # Load the generated modules — one line in an initializer or spec
+    # helper (loading happens only when you call this; skip it and
+    # require files yourself if you'd rather):
+    #
+    #      GraphWeaver.load_generated!
+    #
+    # In Rails, prefer this over autoloading: Zeitwerk would expect
+    # Generated::PersonQuery from generated/person_query.rb, and
+    # generated code only changes on regeneration anyway (restart, like
+    # a schema migration).
+    def load_generated!(path = nil)
+      paths = path ? [path] : generated_paths
+      files = paths.flat_map { |dir| Dir[File.join(dir, "**/*.rb")].sort }.uniq
+      files.each { |file| require File.expand_path(file) }
+      log(:info) { "loaded #{files.size} generated module(s) from #{paths.join(", ")}" }
+      files
+    end
+
+    # the conventional schema dump, required
+    def locate_schema!
+      SchemaLoader.locate or raise Error,
+        "no schema dump at #{schema_path} (.json/.graphql/.gql) — pass schema:, or cache one: GraphWeaver.new(url, cache: true).schema"
+    end
+    private :locate_schema!
+
+    # (filename, source) per artifact: shared_inputs (the default) emits
+    # every variable type once into inputs.rb, with query modules
+    # aliasing what they use — the difference between hundreds of
+    # duplicated bool_exp structs and one copy per schema.
+    def generation_plan(queries:, schema:, client:, shared_inputs:, inputs_module: self.inputs_module)
+      namespace = shared_inputs ? inputs_module : nil
+      used = { inputs: [], enums: [], mapped: [] }
+
+      plan = Dir[File.join(queries, "*.graphql")].sort.map do |path|
+        base = File.basename(path, ".graphql")
+        codegen = Codegen.new(
+          schema:,
+          query: File.read(path),
+          module_name: "#{Inflect.camelize(base)}Query",
+          client:,
+          inputs_namespace: namespace,
+        )
+        source = codegen.generate
+        codegen.variable_type_names.each { |kind, names| used[kind] |= names }
+        ["#{base}_query.rb", source]
+      end
+
+      if namespace && used.values.any?(&:any?)
+        shared = Codegen.generate_inputs(
+          schema:, module_name: namespace,
+          input_types: used[:inputs], enum_types: used[:enums] + used[:mapped],
+        )
+        plan = shared.to_a + plan
+      end
+
+      plan
+    end
+    private :generation_plan
+
+    # Default input coercion for scalars that don't say coerce: themselves,
+    # resolved lazily at generation time (so set it any time before you
+    # generate — no reset_scalars! ordering dance):
+    #
+    #      GraphWeaver.auto_coerce = true
+    #
+    # Convertible built-ins take their conversion (Int accepts 5/"5"),
+    # and any scalar with a full cast/serialize pair (Date, your Money)
+    # accepts its raw wire form. An explicit coerce: true/false/Symbol on
+    # a registration always wins.
+    attr_accessor :auto_coerce
+
     # Teach the generator how a GraphQL custom scalar deserializes into a
     # rich Ruby object (and serializes back onto the wire when used as a
     # variable):
     #
-    #   GraphWeaver.register_scalar("Money", type: Money, requires: "bigdecimal")
+    #      GraphWeaver.register_scalar("Money", Money, requires: "bigdecimal")
     #
     # A field typed `Money` then generates `const :price, T.nilable(Money)`
     # and casts with `Money.parse(...)` in from_h. Pass a real class as
@@ -44,16 +257,54 @@ module GraphWeaver
     # serializing — it raises on bad input, so some safety survives. Built-in
     # scalars are pre-registered the same way, so this also overrides them.
     # Call before generating.
-    def register_scalar(graphql_name, type:, cast: nil, serialize: nil, requires: nil, coerce: false)
-      Codegen.register_scalar(graphql_name, type:, cast:, serialize:, requires:, coerce:)
+    def register_scalar(graphql_name, type, cast: nil, serialize: nil, requires: nil, coerce: nil)
+      Codegen.register_scalar(graphql_name, type, cast:, serialize:, requires:, coerce:)
+    end
+
+    # Map a GraphQL enum onto an app-owned T::Enum, so generated code
+    # speaks YOUR enum — casting wire values in, serializing members out:
+    #
+    #      GraphWeaver.register_enum("Species", PetKind)
+    #
+    # The mapping is inferred by name ("CAT" <-> PetKind::Cat); map: pins
+    # renames, fallback: absorbs unknown wire values on cast (inputs stay
+    # strict), requires: names files the generated code should require.
+    # Generation fails naming any schema value that doesn't resolve —
+    # exhaustiveness checked ahead of runtime. Global; client.register_enum
+    # scopes to one client.
+    def register_enum(graphql_name, type, map: nil, fallback: nil, requires: nil)
+      Codegen.register_enum(graphql_name, type, map:, fallback:, requires:)
+    end
+
+    # Bulk, inference-only form: register_enums("Species" => PetKind, ...)
+    def register_enums(mappings)
+      Codegen.register_enums(mappings)
+    end
+
+    # Include app-owned helper modules into every struct generated from a
+    # GraphQL type — derived values live as methods next to the honest
+    # wire data, and srb tc checks them against each query's selection:
+    #
+    #      GraphWeaver.register_type("Pet", PetHelpers)
+    #
+    # Or build the mixin inline with a block (module_eval'd into an
+    # auto-named module — quick, but invisible to srb tc):
+    #
+    #      GraphWeaver.register_type("Pet") do
+    #        def display_name = "#{name} the pet"
+    #      end
+    #
+    # Additive (repeated and client-scoped registrations stack). Global;
+    # client.register_type scopes to one client.
+    def register_type(graphql_name, *mixins, requires: nil, &block)
+      Codegen.register_type(graphql_name, *mixins, requires:, &block)
     end
 
     # Restore the built-in scalars, dropping every custom registration —
-    # the clean slate to reach for between tests or to undo overrides. Pass
-    # coerce: true to reload the built-ins with input coercion enabled
-    # (Float accepts 5/"5", etc.), then register your own scalars on top.
-    def reset_scalars!(coerce: false)
-      Codegen.reset_scalars!(coerce:)
+    # the clean slate to reach for between tests or to undo overrides.
+    # (Coercible built-ins are auto_coerce's job, not a reset flavor.)
+    def reset_scalars!
+      Codegen.reset_scalars!
     end
 
     # Empty the scalar registry entirely, built-ins included (see
@@ -64,42 +315,42 @@ module GraphWeaver
 
     # Parse a query into a typed query module:
     #
-    #   PersonQuery = GraphWeaver.parse(schema:, query: "queries/person.graphql")
+    #      PersonQuery = GraphWeaver.parse(schema:, query: "queries/person.graphql")
     #
     # query is a .graphql/.gql path (module name derived from the file
     # name) or a raw query string (name derived from the operation name,
     # falling back to "Query" for anonymous operations — collisions are
     # impossible since each parse gets its own container). Pass name: to
-    # override, executor: to set the module's transport.
-    def parse(schema:, query:, name: nil, executor: nil)
+    # override, client: to bake the module's default client/transport.
+    def parse(schema:, query:, name: nil, client: nil, scalars: nil, enums: nil, types: nil)
       if query.end_with?(".graphql", ".gql")
         name ||= "#{Inflect.camelize(File.basename(query, ".*"))}Query"
         query = File.read(query)
       end
 
-      Codegen.parse(schema:, query:, module_name: name, executor:)
+      Codegen.parse(schema:, query:, module_name: name, client:, scalars:, enums:, types:)
     end
 
-    # One-shot dynamic execution — no module handling, no build step:
+    # One-shot dynamic execution — a throwaway client, no build step:
     #
-    #   GraphWeaver.execute(schema:, query:, variables: { id: "1" })   # => Response
-    #   GraphWeaver.execute!(schema:, query:, variables: { id: "1" })  # => Result (or raise)
+    #      GraphWeaver.execute(schema, "query($id: ID!) { ... }", id: "1")   # => Response
+    #      GraphWeaver.execute!(url, "query { viewer { login } }")           # => Result (or raise)
     #
-    # Mirrors a generated module: execute returns the Response envelope,
-    # execute! returns the typed result directly and raises QueryError on
-    # top-level errors. Transport precedence: executor: param, then
-    # GraphWeaver.executor, then in-process execution against schema.
-    # Variable keys may be graphql-cased strings or ruby symbols.
-    def execute(schema:, query:, variables: {}, executor: nil)
-      executor ||= @executor || schema
-      mod = parse(schema:, query:, executor:)
-      kwargs = variables.to_h { |key, value| [Inflect.underscore(key.to_s).to_sym, value] }
-      mod.execute(**kwargs)
+    # The first argument is a url or schema source, exactly as
+    # GraphWeaver.new; this is Client#execute on a client you don't keep.
+    # (A url source introspects the schema on every call — keep a client
+    # for more than one query.) Variables are plain kwargs, as on a
+    # generated module (nothing reserved). execute returns the
+    # Response envelope, execute! the typed result, raising QueryError on
+    # top-level errors.
+    def execute(source, query, **variables)
+      client = source.is_a?(Client) ? source : Client.new(source)
+      client.execute(query, **variables)
     end
 
     # execute + data! — the typed result, or a raised QueryError. See execute.
-    def execute!(schema:, query:, variables: {}, executor: nil)
-      execute(schema:, query:, variables:, executor:).data!
+    def execute!(source, query, **variables)
+      execute(source, query, **variables).data!
     end
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: graph_weaver
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.1
 platform: ruby
 authors:
 - Daniel Pepper
@@ -37,6 +37,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: apollo-federation
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: bigdecimal
   requirement: !ruby/object:Gem::Requirement
@@ -93,6 +107,34 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: redcarpet
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
@@ -163,12 +205,27 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: yard
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 description: A typed GraphQL client for Ruby — generate Sorbet T::Structs from queries,
   with federation, extensibility, and testing in mind
 executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- ".yardopts"
 - CHANGELOG.md
 - Gemfile
 - Gemfile.lock
@@ -177,32 +234,44 @@ files:
 - NOTES.md
 - PLAN.md
 - README.md
+- docs/cassettes.md
 - docs/errors.md
 - docs/generated_modules.md
+- docs/getting_started.md
+- docs/logging.md
 - docs/real_world.md
 - docs/scalars.md
 - docs/testing.md
+- docs/transports.md
 - graph_weaver.gemspec
 - lib/graph_weaver.rb
+- lib/graph_weaver/client.rb
 - lib/graph_weaver/codegen.rb
 - lib/graph_weaver/codegen/emit.rb
+- lib/graph_weaver/codegen/enum_type.rb
 - lib/graph_weaver/codegen/nodes.rb
 - lib/graph_weaver/codegen/scalar_type.rb
 - lib/graph_weaver/directive_defaults_patch.rb
 - lib/graph_weaver/errors.rb
-- lib/graph_weaver/faraday_executor.rb
-- lib/graph_weaver/http_executor.rb
+- lib/graph_weaver/hints.rb
 - lib/graph_weaver/inflect.rb
+- lib/graph_weaver/input_struct.rb
+- lib/graph_weaver/logging.rb
+- lib/graph_weaver/railtie.rb
 - lib/graph_weaver/response.rb
+- lib/graph_weaver/retry.rb
 - lib/graph_weaver/rspec.rb
 - lib/graph_weaver/schema_loader.rb
 - lib/graph_weaver/selection.rb
+- lib/graph_weaver/tasks.rb
 - lib/graph_weaver/testing.rb
 - lib/graph_weaver/testing/cassette.rb
 - lib/graph_weaver/testing/failure.rb
-- lib/graph_weaver/testing/fake_executor.rb
-- lib/graph_weaver/testing/rspec.rb
+- lib/graph_weaver/testing/fake_client.rb
 - lib/graph_weaver/testing/values.rb
+- lib/graph_weaver/transport.rb
+- lib/graph_weaver/transport/faraday.rb
+- lib/graph_weaver/transport/http.rb
 - lib/graph_weaver/version.rb
 homepage: https://github.com/dpep/graph_weaver
 licenses:

data/lib/graph_weaver/faraday_executor.rb

@@ -1,61 +0,0 @@
-# typed: true
-# frozen_string_literal: true
-
-require "faraday"
-require "json"
-
-require_relative "errors"
-
-# Faraday-backed transport. Opt-in (faraday is not a hard dependency):
-#
-#   require "graph_weaver/faraday_executor"
-#
-#   # simplest: build a default connection from a url
-#   GraphWeaver::FaradayExecutor.new("https://api.example.com/graphql")
-#
-#   # customize middleware while building
-#   GraphWeaver::FaradayExecutor.new(url) do |conn|
-#     conn.request :authorization, "Bearer", -> { Tokens.fetch }
-#     conn.response :logger
-#   end
-#
-#   # or bring a fully configured connection
-#   GraphWeaver::FaradayExecutor.new(Faraday.new(url:) { |conn| ... })
-class GraphWeaver::FaradayExecutor
-  # Faraday's network-level failures — added to the shared, extensible
-  # transport-error set.
-  GraphWeaver.register_transport_error(
-    Faraday::ConnectionFailed, Faraday::TimeoutError, Faraday::SSLError
-  )
-
-  def initialize(url_or_connection, headers: {}, &block)
-    @connection = case url_or_connection
-    when Faraday::Connection
-      url_or_connection
-    else
-      # Faraday appends the default adapter when the block doesn't set one
-      Faraday.new(url: url_or_connection, headers:, &block)
-    end
-  end
-
-  def execute(query, variables: {})
-    response = begin
-      @connection.post do |request|
-        request.headers["Content-Type"] = "application/json"
-        request.body = JSON.generate(query:, variables:)
-      end
-    rescue *GraphWeaver.transport_errors.to_a => e
-      # never got a response — connection refused/reset, TLS, timeout
-      raise GraphWeaver::TransportError, "#{e.class}: #{e.message}"
-    end
-
-    # reached the server, but it returned a non-2xx status
-    unless response.success?
-      raise GraphWeaver::ServerError.new(status: response.status, body: response.body.to_s)
-    end
-
-    body = response.body
-    # a caller's connection may already parse json via middleware
-    body.is_a?(String) ? JSON.parse(body) : body
-  end
-end

data/lib/graph_weaver/http_executor.rb

@@ -1,44 +0,0 @@
-# typed: true
-# frozen_string_literal: true
-
-require "json"
-require "sorbet-runtime"
-require "net/http"
-require "openssl"
-require "uri"
-
-require_relative "errors"
-
-# Minimal HTTP transport satisfying the generated modules' executor
-# interface: execute(query, variables:) => {"data" => ..., "errors" => ...}
-class GraphWeaver::HttpExecutor
-  # net/http's own network-level failures (Errno/SocketError/IOError are
-  # already seeded) — added to the shared, extensible transport-error set.
-  GraphWeaver.register_transport_error(Timeout::Error, OpenSSL::SSL::SSLError)
-
-  def initialize(url, headers: {})
-    @uri = URI(url)
-    @headers = headers
-  end
-
-  def execute(query, variables: {})
-    request = Net::HTTP::Post.new(@uri, { "Content-Type" => "application/json" }.merge(@headers))
-    request.body = JSON.generate(query:, variables:)
-
-    response = begin
-      Net::HTTP.start(@uri.hostname, @uri.port, use_ssl: @uri.scheme == "https") do |http|
-        http.request(request)
-      end
-    rescue *GraphWeaver.transport_errors.to_a => e
-      # never got a response — DNS, connection refused/reset, TLS, timeout
-      raise GraphWeaver::TransportError, "#{e.class}: #{e.message}"
-    end
-
-    # reached the server, but it returned a non-2xx status
-    unless response.is_a?(Net::HTTPSuccess)
-      raise GraphWeaver::ServerError.new(status: response.code.to_i, body: response.body)
-    end
-
-    JSON.parse(T.must(response.body))
-  end
-end

data/lib/graph_weaver/testing/rspec.rb

@@ -1,5 +0,0 @@
-# typed: true
-# frozen_string_literal: true
-
-# moved — the canonical entry point is:
-require_relative "../rspec"