graph_weaver 0.1.0 → 0.2.0

data/lib/graph_weaver/selection.rb

@@ -4,7 +4,7 @@
 require "graphql"
 
 module GraphWeaver
-  # Shared query-selection walking — the rules Codegen, FakeExecutor, and
+  # Shared query-selection walking — the rules Codegen, FakeClient, and
   # the cassette Anonymizer all follow, in one place so they can't drift:
   # how fragments flatten into selections, and when a type condition
   # applies. Hosts set @schema and call load_operation before walking.
@@ -27,7 +27,7 @@ module GraphWeaver
       case operation&.operation_type
       when "query", nil then @schema.query
       when "mutation" then @schema.mutation
-      else raise NotImplementedError, "unsupported operation: #{operation.operation_type}"
+      else raise GraphWeaver::Error, "unsupported operation: #{operation.operation_type}"
       end
     end
 
@@ -47,7 +47,7 @@ module GraphWeaver
           end
           each_field(type, fragment.selections, &block) if applies?(fragment.type.name, type)
         else
-          raise NotImplementedError, "unsupported selection: #{selection.class}"
+          raise GraphWeaver::Error, "unsupported selection: #{selection.class}"
         end
       end
     end

data/lib/graph_weaver/tasks.rb

@@ -0,0 +1,71 @@
+# typed: ignore — Rake DSL at top level, loaded from Rakefiles
+# frozen_string_literal: true
+
+# Rake tasks — add to your Rakefile:
+#
+#      require "graph_weaver/tasks"
+#
+# The tasks use the conventional paths (GraphWeaver.queries_path /
+# generated_path / schema_path — override in your Rakefile or an
+# initializer). Register custom scalars before the tasks run — they're
+# baked into generated source.
+#
+#      rake graph_weaver:generate   # queries_path -> generated_path
+#      rake graph_weaver:verify     # fail if generated files are stale (CI)
+require_relative "../graph_weaver"
+
+# in Rails, run app config first (initializers register scalars/enums/
+# helpers, and they're baked into generated source)
+GRAPH_WEAVER_DEPS = Rake::Task.task_defined?("environment") ? ["environment"] : []
+
+namespace :graph_weaver do
+  desc "Generate typed query modules (#{GraphWeaver.queries_path} -> #{GraphWeaver.generated_path})"
+  task generate: GRAPH_WEAVER_DEPS do
+    # schema auto-located at GraphWeaver.schema_path, any supported extension
+    GraphWeaver.generate!.each { |path| puts "wrote #{path}" }
+  end
+
+  desc "Verify generated query modules are up to date"
+  task verify: GRAPH_WEAVER_DEPS do
+    GraphWeaver.verify_generated!
+    puts "generated queries up to date"
+  end
+
+  namespace :schema do
+    # both tasks re-introspect from the url recorded in the dump
+    # (GRAPHWEAVER_AUTH supplies a token for private APIs)
+
+    desc "Fail when the server's schema has drifted from the local dump"
+    task :verify do
+      path = GraphWeaver::SchemaLoader.locate_path or abort "no schema dump at #{GraphWeaver.schema_path}"
+      if GraphWeaver::SchemaLoader.stale?(path)
+        abort "#{path} is stale — the server's schema has drifted (rake graph_weaver:schema:refresh)"
+      end
+
+      puts "#{path} matches the server"
+    end
+
+    desc "Re-introspect the recorded url and rewrite the local dump"
+    task :refresh do
+      path = GraphWeaver::SchemaLoader.locate_path or abort "no schema dump at #{GraphWeaver.schema_path}"
+      meta = GraphWeaver::SchemaLoader.provenance(path) or abort "#{path} records no source url"
+
+      transport = GraphWeaver.new(meta["url"], auth: ENV["GRAPHWEAVER_AUTH"]).transport
+      GraphWeaver::SchemaLoader.introspect(transport, cache: path, ttl: 0)
+      puts "refreshed #{path} from #{meta["url"]}"
+    end
+  end
+
+  namespace :cassettes do
+    desc "Anonymize every cassette in Testing.config.cassette_dir (PII-safe to commit)"
+    task :anonymize do
+      require "graph_weaver/testing"
+
+      schema = GraphWeaver::SchemaLoader.load(GraphWeaver.schema_path)
+      Dir[File.join(GraphWeaver::Testing.config.cassette_dir, "*.yml")].sort.each do |path|
+        GraphWeaver::Testing::Cassette.new(path).anonymize!(schema:)
+        puts "anonymized #{path}"
+      end
+    end
+  end
+end

data/lib/graph_weaver/testing/cassette.rb

@@ -7,12 +7,12 @@ require "yaml"
 
 module GraphWeaver
   module Testing
-    # Raised by ReplayExecutor when a request has no recording.
+    # Raised by Replayer when a request has no recording.
     class MissingRecording < GraphWeaver::Error
       def initialize(path:, query:)
         super(<<~MSG.strip)
           no recording for this request in #{path} — re-record it
-          (RecordingExecutor / Cassette.use with a live executor, or delete
+          (Recorder / Cassette.use with a live client, or delete
           the cassette to start over). Query:
           #{query.strip[0, 200]}
         MSG
@@ -23,12 +23,12 @@ module GraphWeaver
     # cassette is a YAML file of {query, variables, response} entries,
     # keyed on the normalized query + variables.
     #
-    #   # record against a real executor, replay when the file exists:
-    #   executor = GraphWeaver::Testing::Cassette.use("github", executor: real)
+    #      # record against a real client, replay when the file exists:
+    #      client = GraphWeaver::Testing::Cassette.use("github", client: real)
     #
     # Cassettes hold real responses — anonymize before committing:
     #
-    #   Cassette.new("spec/cassettes/github.yml").anonymize!(schema:)
+    #      Cassette.new("spec/cassettes/github.yml").anonymize!(schema:)
     #
     # keeps every shape (list lengths, null positions, enums, __typename,
     # id relationships via a consistent mapping) while replacing values
@@ -44,21 +44,26 @@ module GraphWeaver
       def exist? = File.exist?(@path)
       def size = @entries.size
 
-      # replay when recorded, record when not (VCR's once mode).
-      # executor: is required to record; omit it to replay-or-raise.
-      def self.use(path, executor: nil)
+      # Replay when recorded, record when not (VCR's once mode).
+      # client: is required to record; omit it to replay-or-raise.
+      # With Testing.config.record on (or GRAPHWEAVER_RECORD=1), always
+      # records — the "just re-record everything" switch.
+      def self.use(path, client: nil)
         cassette = new(path)
-        if cassette.exist?
-          ReplayExecutor.new(cassette)
-        elsif executor
-          RecordingExecutor.new(executor, cassette)
+        if Testing.config.record && client
+          Recorder.new(client, cassette)
+        elsif cassette.exist?
+          Replayer.new(cassette)
+        elsif client
+          Recorder.new(client, cassette)
         else
-          raise MissingRecording.new(path: cassette.path, query: "(no executor to record with)")
+          raise MissingRecording.new(path: cassette.path, query: "(no client to record with)")
         end
       end
 
       def lookup(query, variables)
-        @entries.find { |entry| entry["key"] == self.class.key(query, variables) }
+        wanted = self.class.key(query, variables)
+      @entries.find { |entry| entry["key"] == wanted }
       end
 
       def record(query, variables, response)
@@ -74,7 +79,7 @@ module GraphWeaver
       end
 
       # Replace recorded response values with fakes, preserving structure.
-      # Walks each entry's query against the schema (like FakeExecutor,
+      # Walks each entry's query against the schema (like FakeClient,
       # but transforming what's there instead of generating from scratch).
       def anonymize!(schema:, seed: nil, mode: nil)
         anonymizer = Anonymizer.new(schema:, seed:, mode:)
@@ -98,15 +103,31 @@ module GraphWeaver
       end
     end
 
-    # Tees requests through a live executor and records every response.
-    class RecordingExecutor
-      def initialize(executor, cassette)
-        @executor = executor
+    # Tees requests through a live client and records every response.
+    # With Testing.config.anonymize (or anonymize: true), responses are
+    # anonymized as they're recorded — and the anonymized version is what
+    # the caller sees too, so assertions written now hold on replay.
+    class Recorder
+      def initialize(client, cassette, anonymize: nil)
+        @client = client
         @cassette = cassette.is_a?(Cassette) ? cassette : Cassette.new(cassette)
+
+        config = Testing.config
+        if anonymize.nil? ? config.anonymize : anonymize
+          unless config.schema
+            raise ArgumentError, "anonymizing recordings needs GraphWeaver::Testing.config.schema"
+          end
+
+          @anonymizer = Anonymizer.new(schema: config.schema, seed: config.seed)
+        end
       end
 
       def execute(query, variables: {})
-        response = @executor.execute(query, variables:).to_h
+        response = @client.execute(query, variables:).to_h
+        if @anonymizer && (data = response["data"])
+          response = response.merge("data" => @anonymizer.anonymize(query, data))
+        end
+
         @cassette.record(query, variables, response)
         response
       end
@@ -114,7 +135,7 @@ module GraphWeaver
 
     # Serves recorded responses; raises MissingRecording on unknown
     # requests rather than silently faking.
-    class ReplayExecutor
+    class Replayer
       def initialize(cassette)
         @cassette = cassette.is_a?(Cassette) ? cassette : Cassette.new(cassette)
       end

data/lib/graph_weaver/testing/failure.rb

@@ -5,19 +5,19 @@ require "json"
 
 module GraphWeaver
   module Testing
-    # Canned failure executors — each produces exactly what the real
+    # Canned failure clients — each produces exactly what the real
     # transports produce, so error-handling paths are testable without a
     # server that misbehaves on cue:
     #
-    #   PersonQuery.execute(id: "1", executor: Failure.transport)   # TransportError
-    #   PersonQuery.execute(id: "1", executor: Failure.server(status: 502))
-    #   PersonQuery.execute(id: "1", executor: Failure.throttled)   # QueryError, code THROTTLED
-    #   PersonQuery.execute(id: "1", executor: Failure.stale_schema) # schema_stale? => true
+    #      PersonQuery.execute(id: "1", Failure.transport)   # TransportError
+    #      PersonQuery.execute(id: "1", Failure.server(status: 502))
+    #      PersonQuery.execute(id: "1", Failure.throttled)   # QueryError, code THROTTLED
+    #      PersonQuery.execute(id: "1", Failure.stale_schema) # schema_stale? => true
     #
-    # For type mismatches, corrupt the wire with a FakeExecutor override:
-    #   FakeExecutor.new(schema:, overrides: { "Person.birthday" => 123 })
+    # For type mismatches, corrupt the wire with a FakeClient override:
+    #      FakeClient.new(schema:, overrides: { "Person.birthday" => 123 })
     # casting then raises GraphWeaver::TypeError, exactly as a bad server
-    # payload would. For partial failures, see FakeExecutor's fail_at:.
+    # payload would. For partial failures, see FakeClient's fail_at:.
     module Failure
       include Kernel # for sorbet
       module_function
@@ -25,7 +25,7 @@ module GraphWeaver
       # the request never reaches the server — cause preserved, like the
       # bundled transports do
       def transport(message = "simulated network failure", cause: SocketError)
-        FailureExecutor.new do
+        FailureClient.new do
           raise cause, message
         rescue cause => e
           raise GraphWeaver::TransportError, e.message
@@ -34,7 +34,7 @@ module GraphWeaver
 
       # the server answered non-2xx
       def server(status: 500, body: "simulated server error")
-        FailureExecutor.new { raise GraphWeaver::ServerError.new(status:, body:) }
+        FailureClient.new { raise GraphWeaver::ServerError.new(status:, body:) }
       end
 
       # top-level GraphQL errors: strings, or hashes with message/path/
@@ -47,7 +47,7 @@ module GraphWeaver
         response = { "errors" => normalized }
         response["data"] = data if data
         response["extensions"] = JSON.parse(JSON.generate(extensions)) unless extensions.empty?
-        FailureExecutor.new { response }
+        FailureClient.new { response }
       end
 
       def throttled
@@ -60,9 +60,9 @@ module GraphWeaver
       # the casualty explicitly, or pass schema: to sample a real
       # type/field (as if the server just dropped it):
       #
-      #   Failure.stale_schema(type: "Person", field: "name")
-      #   Failure.stale_schema(schema: MySchema)             # random real field
-      #   Failure.stale_schema(schema: MySchema, seed: 42)   # reproducibly random
+      #      Failure.stale_schema(type: "Person", field: "name")
+      #      Failure.stale_schema(schema: MySchema)             # random real field
+      #      Failure.stale_schema(schema: MySchema, seed: 42)   # reproducibly random
       def stale_schema(field: nil, type: nil, schema: nil, seed: nil)
         if schema && (field.nil? || type.nil?)
           rng = Random.new(seed || GraphWeaver::Testing.config.seed || Random.new_seed)
@@ -79,7 +79,7 @@ module GraphWeaver
     end
 
     # runs the block per request — raise or return an envelope
-    class FailureExecutor
+    class FailureClient
       def initialize(&response)
         @response = response
       end
@@ -89,20 +89,20 @@ module GraphWeaver
       end
     end
 
-    # Delegates each call to the next executor in line (the last one
+    # Delegates each call to the next client in line (the last one
     # repeats) — fail N times, then succeed, for retry/backoff testing:
     #
-    #   SequenceExecutor.new(Failure.transport, Failure.transport, fake)
-    class SequenceExecutor
-      def initialize(*executors)
-        @executors = executors.flatten
+    #      Sequence.new(Failure.transport, Failure.transport, fake)
+    class Sequence
+      def initialize(*clients)
+        @clients = clients.flatten
         @calls = 0
       end
 
       def execute(query, variables: {})
-        executor = @executors[[@calls, @executors.size - 1].min]
+        client = @clients[[@calls, @clients.size - 1].min]
         @calls += 1
-        executor.execute(query, variables:)
+        client.execute(query, variables:)
       end
     end
   end

data/lib/graph_weaver/testing/{fake_executor.rb → fake_client.rb}

@@ -4,12 +4,12 @@
 require "graphql"
 require "json"
 
-# An executor that fabricates schema-correct responses for whatever query
+# A fake client that fabricates schema-correct responses for whatever query
 # arrives — the zero-setup way to test code built on generated modules:
 #
-#   fake = GraphWeaver::Testing::FakeExecutor.new(schema:)
-#   result = PersonQuery.execute!(id: "1", executor: fake)
-#   result.person.name  # => a plausible String, typed and castable
+#      fake = GraphWeaver::Testing::FakeClient.new(schema:)
+#      result = PersonQuery.execute!(id: "1", fake — positionally)
+#      result.person.name  # => a plausible String, typed and castable
 #
 # Values are type-correct by construction (real enum values, valid
 # __typename members for unions/interfaces, iso8601 for date scalars), so
@@ -22,10 +22,10 @@ require "json"
 # also the way to simulate a corrupt payload — casting raises
 # GraphWeaver::TypeError.)
 #
-#   FakeExecutor.new(schema:, overrides: {
-#     "Person.name" => "Daniel",
-#     "email" => -> { "test@example.com" },
-#   })
+#      FakeClient.new(schema:, overrides: {
+#        "Person.name" => "Daniel",
+#        "email" => -> { "test@example.com" },
+#      })
 #
 # Partial failures: fail_at simulates a field-level error with
 # spec-correct null propagation — the field's error lands in the errors
@@ -33,8 +33,8 @@ require "json"
 # bubble past non-null positions to the nearest nullable ancestor, just
 # like a real server:
 #
-#   FakeExecutor.new(schema:, fail_at: "person.pets.name")
-#   FakeExecutor.new(schema:, fail_at: { path: "person.email", message: "hidden", code: "PRIVATE" })
+#      FakeClient.new(schema:, fail_at: "person.pets.name")
+#      FakeClient.new(schema:, fail_at: { path: "person.email", message: "hidden", code: "PRIVATE" })
 #
 # errors: appends verbatim top-level errors alongside the fake data.
 #
@@ -43,11 +43,11 @@ require "json"
 # so casting raises GraphWeaver::TypeError. One spec checks the failure
 # path; every other spec gets working data:
 #
-#   FakeExecutor.new(schema:, corrupt: "Person.birthday")
+#      FakeClient.new(schema:, corrupt: "Person.birthday")
 #
-# seed: makes a run reproducible (also seeds faker). Per-executor options
+# seed: makes a run reproducible (also seeds faker). Per-instance options
 # fall back to GraphWeaver::Testing.config.
-class GraphWeaver::Testing::FakeExecutor
+class GraphWeaver::Testing::FakeClient
   include GraphWeaver::Selection
 
   # sentinel: a simulated failure bubbling up to the nearest nullable spot

data/lib/graph_weaver/testing/values.rb

@@ -3,7 +3,7 @@
 
 require "date"
 
-# The value engine behind FakeExecutor and Cassette#anonymize!: seeded,
+# The value engine behind FakeClient and Cassette#anonymize!: seeded,
 # type-correct scalar generation with optional faker-backed semantics
 # matched on field names — strings (name/email/url/...) and numbers
 # (age/price/count/latitude/...) alike. Keeps a consistent id mapping so
@@ -47,7 +47,7 @@ class GraphWeaver::Testing::Values
 
     if @mode == :faker
       # rebind per call: several Values instances may interleave (e.g. two
-      # seeded executors), and faker's rng is global
+      # seeded fakes), and faker's rng is global
       ::Faker::Config.random = @rng
       case type_name
       when "String"

data/lib/graph_weaver/testing.rb

@@ -14,29 +14,31 @@ end
 # Opt-in test tooling: require "graph_weaver/testing" from your spec
 # helper (never from production code). Configure once, initializer-style:
 #
-#   GraphWeaver::Testing.configure do |config|
-#     config.schema = MySchema                  # for auto_fake / cassettes
-#     config.seed = 42                          # reproducible fakes
-#     config.mode = :faker                      # or :literal; nil = auto
-#     config.overrides = { "Person.name" => "Daniel" }
-#     config.list_size = 2..4
-#     config.null_chance = 0.1                  # nullable fields go nil sometimes
-#     config.cassette_dir = "spec/cassettes"
-#   end
+#      GraphWeaver::Testing.configure do |config|
+#        config.schema = MySchema                  # for auto_fake / cassettes
+#        config.seed = 42                          # reproducible fakes
+#        config.mode = :faker                      # or :literal; nil = auto
+#        config.overrides = { "Person.name" => "Daniel" }
+#        config.list_size = 2..4
+#        config.null_chance = 0.1                  # nullable fields go nil sometimes
+#        config.cassette_dir = "spec/cassettes"
+#      end
 #
 # mode picks how values are fabricated:
-#   :faker   — semantic, field-name matched (requires the faker gem)
-#   :literal — plain type-derived values ("name-1", seeded numbers)
-#   nil      — auto: :faker when the gem is loaded, else :literal
+#      :faker   — semantic, field-name matched (requires the faker gem)
+#      :literal — plain type-derived values ("name-1", seeded numbers)
+#      nil      — auto: :faker when the gem is loaded, else :literal
 #
 # rspec users: require "graph_weaver/rspec" instead — it hooks the suite
-# (seed from rspec, optional auto-faked executor per example).
+# (seed from rspec, optional auto-faked client per example).
 module GraphWeaver
   module Testing
     MODES = [:faker, :literal].freeze
 
     class Config
-      attr_accessor :overrides, :seed, :list_size, :null_chance, :schema, :cassette_dir, :auto_fake
+      attr_accessor :overrides, :seed, :list_size, :null_chance, :cassette_dir, :auto_fake,
+        :record, :anonymize
+      attr_writer :schema
       attr_reader :mode
 
       def initialize
@@ -47,7 +49,21 @@ module GraphWeaver
         @mode = nil # auto
         @schema = nil
         @cassette_dir = "spec/cassettes"
-        @auto_fake = false
+        # on by default — engages only when a schema resolves (below), so
+        # requiring graph_weaver/rspec in a conventional app is
+        # zero-config; config.auto_fake = false opts out
+        @auto_fake = true
+        # GRAPHWEAVER_RECORD=1 rspec ...  -> Cassette.use re-records
+        @record = !ENV["GRAPHWEAVER_RECORD"].to_s.empty?
+        # anonymize responses as they're recorded (needs config.schema)
+        @anonymize = false
+      end
+
+      # the explicitly configured schema, else the conventional dump
+      # (SchemaLoader.locate at GraphWeaver.schema_path) — nil when
+      # neither exists, which quietly disables auto_fake
+      def schema
+        @schema ||= GraphWeaver::SchemaLoader.locate
       end
 
       def mode=(mode)
@@ -85,6 +101,6 @@ module GraphWeaver
 end
 
 require_relative "testing/values"
-require_relative "testing/fake_executor"
+require_relative "testing/fake_client"
 require_relative "testing/failure"
 require_relative "testing/cassette"

data/lib/graph_weaver/transport/faraday.rb

@@ -0,0 +1,56 @@
+# typed: true
+# frozen_string_literal: true
+
+require "faraday"
+
+require_relative "../transport"
+
+module GraphWeaver
+  class Transport
+    # Faraday-backed transport. Opt-in (faraday is not a hard dependency):
+    #
+    #      require "graph_weaver/transport/faraday"
+    #
+    #      # simplest: build a default connection from a url
+    #      GraphWeaver::Transport::Faraday.new("https://api.example.com/graphql")
+    #
+    #      # customize middleware while building
+    #      GraphWeaver::Transport::Faraday.new(url) do |conn|
+    #        conn.request :authorization, "Bearer", -> { Tokens.fetch }
+    #        conn.response :logger
+    #      end
+    #
+    #      # or bring a fully configured connection
+    #      GraphWeaver::Transport::Faraday.new(Faraday.new(url:) { |conn| ... })
+    class Faraday < Transport
+      # 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
+        @url = @connection.url_prefix.to_s
+      end
+
+      private
+
+      sig { override.params(body: String).returns([Integer, T.untyped]) }
+      def post(body)
+        response = @connection.post do |request|
+          request.headers["Content-Type"] = "application/json"
+          request.body = body
+        end
+
+        [response.status, response.body]
+      end
+    end
+  end
+end

data/lib/graph_weaver/transport/http.rb

@@ -0,0 +1,87 @@
+# typed: true
+# frozen_string_literal: true
+
+require "net/http"
+require "openssl"
+require "uri"
+
+require_relative "../transport"
+
+module GraphWeaver
+  class Transport
+    # Minimal net/http transport — zero dependencies, loaded by default:
+    #
+    #      GraphWeaver::Transport::HTTP.new(url, headers: { ... }, read_timeout: 10)
+    #
+    # Timeouts surface as TransportError (retriable). The connection is
+    # persistent (keep-alive), serialized behind a mutex — one socket per
+    # transport, dropped on any failure so the next call starts fresh.
+    # For real connection pooling and a middleware ecosystem, use
+    # Transport::Faraday.
+    class HTTP < Transport
+      # 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: {}, open_timeout: 10, read_timeout: 30, keep_alive_timeout: 2)
+        @url = url
+        @uri = URI(url)
+        @headers = headers
+        @open_timeout = open_timeout
+        @read_timeout = read_timeout
+        @keep_alive_timeout = keep_alive_timeout
+        @mutex = Mutex.new
+        @http = T.let(nil, T.nilable(Net::HTTP))
+      end
+
+      private
+
+      sig { override.params(body: String).returns([Integer, T.untyped]) }
+      def post(body)
+        request = Net::HTTP::Post.new(@uri, { "Content-Type" => "application/json" }.merge(@headers))
+        request.body = body
+
+        response = @mutex.synchronize do
+          begin
+            connection.request(request)
+          rescue => e
+            # socket state is unknown — drop it so the next call starts
+            # fresh (retry policy belongs to Retry, not here)
+            disconnect
+            raise e
+          end
+        end
+
+        [response.code.to_i, response.body]
+      end
+
+      # The persistent connection. net/http proactively reconnects when
+      # idle past keep_alive_timeout, so a server-closed keep-alive
+      # socket doesn't produce spurious failures.
+      def connection
+        @http ||= begin
+          GraphWeaver.log(:debug) { "connecting to #{@uri.hostname}:#{@uri.port}" }
+          Net::HTTP.start(
+            @uri.hostname, @uri.port,
+            use_ssl: @uri.scheme == "https",
+            open_timeout: @open_timeout, read_timeout: @read_timeout,
+            keep_alive_timeout: @keep_alive_timeout,
+          )
+        end
+      end
+
+      def disconnect
+        http = @http
+        return unless http
+
+        GraphWeaver.log(:debug) { "dropping connection to #{@uri.hostname}:#{@uri.port}" }
+        http.finish if http.started?
+      rescue IOError
+        # already closed
+      ensure
+        @http = nil
+      end
+    end
+  end
+end