graph_weaver 0.5.1 → 0.6.0

data/lib/graph_weaver/testing.rb

@@ -19,27 +19,32 @@ end
 #      GraphWeaver::Testing.configure do |config|
 #        config.schema = MySchema                  # overrides the derived schema
 #        config.router = { subgraphs: { "reviews" => :fake } }  # or supergraph:,
-#                                                  # when it isn't the dump
+#                                                  # when it isn't the dump, or
+#                                                  # fake: for how those fabricate
 #        config.context = { current_user: }        # baseline GraphQL context
 #        config.default_mode = :fake               # untagged examples (graph_weaver/rspec)
 #        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
+# Anything whose honest answer differs per example belongs on the fake, not
+# here: graphql_fake(null_chance: 1.0) for the empty-state example,
+# graphql_fake(values: :literal) for the one that reads better without
+# faker's prose, and overrides:/list_size: to say what one example's data is.
 #
 # rspec users: require "graph_weaver/rspec" instead — it hooks the suite
 # (seed from rspec, a client per example from its `graphql:` tag).
 module GraphWeaver
   module Testing
-    MODES = [:faker, :literal].freeze
+    # How a fake writes its values, named by the `values:` a fake takes —
+    # graphql_fake(values: :literal), FakeClient.new(values:):
+    #
+    #      :faker   semantic, matched on the field name (needs the faker gem)
+    #      :literal plain type-derived values ("name-1", seeded numbers)
+    #      nil      auto: :faker when the gem is loaded, else :literal
+    VALUE_STYLES = %i[faker literal].freeze
 
     # What an example can run against, named by the rspec tag that selects
     # it — `it "…", graphql: :in_process` (see graph_weaver/rspec):
@@ -50,19 +55,17 @@ module GraphWeaver
     CLIENT_MODES = %i[fake in_process router].freeze
 
     class Config
-      attr_accessor :overrides, :seed, :list_size, :null_chance, :cassette_dir, :context,
+      attr_accessor :overrides, :seed, :list_size, :cassette_dir, :context,
         :record, :anonymize
       # #schema is written plainly and read with a fallback (below), the way
-      # #mode, #router and #default_mode are read plainly and written with a check
+      # #router and #default_mode are read plainly and written with a check
       attr_writer :schema
-      attr_reader :mode, :router, :default_mode
+      attr_reader :router, :default_mode
 
       def initialize
         @overrides = {}
         @seed = nil
         @list_size = 1..3
-        @null_chance = 0.0
-        @mode = nil # auto
         @schema = nil
         @located = nil # the committed dump, once located
         # not under spec/fixtures: `fixtures :all` globs that path for
@@ -100,14 +103,6 @@ module GraphWeaver
       # that never asks for one.
       def explicit_schema = @schema
 
-      def mode=(mode)
-        unless mode.nil? || MODES.include?(mode)
-          raise ArgumentError, "mode: must be one of #{MODES.inspect} (or nil for auto), got #{mode.inspect}"
-        end
-
-        @mode = mode
-      end
-
       def default_mode=(mode)
         unless mode.nil? || CLIENT_MODES.include?(mode)
           raise ArgumentError,
@@ -118,13 +113,14 @@ module GraphWeaver
         @default_mode = mode
       end
 
-      # Router arguments — both keys optional, and each answers a different
+      # Router arguments — every key optional, and each answers a different
       # question. `supergraph:` is for one derivation can't find; without it
       # the conventional dump is used, when that dump is itself a supergraph.
       # `subgraphs:` is for what derivation can't settle, or for `"reviews"
       # => :fake`, which fabricates a subgraph this process doesn't serve —
       # the commonest reason to configure a router at all, and no reason to
-      # have to restate where the supergraph is.
+      # have to restate where the supergraph is. `fake:` says how those
+      # fabricate; graphql_router(fake: …) says it for one example.
       def router=(arguments)
         unless arguments.nil? || arguments.is_a?(Hash)
           raise ArgumentError, "router: must be the arguments to build one, e.g. " \
@@ -137,7 +133,7 @@ module GraphWeaver
           raise ArgumentError, "router: context: is set as config.context — the baseline every " \
             ":in_process and :router example starts from"
         end
-        unknown = (arguments&.keys || []) - %i[supergraph subgraphs]
+        unknown = (arguments&.keys || []) - %i[supergraph subgraphs fake]
         raise ArgumentError, "router: doesn't take #{unknown.join(", ")}" if unknown.any?
 
         @router = arguments
@@ -148,14 +144,18 @@ module GraphWeaver
       # #context is settable, so an example that runs as someone else sets
       # that rather than rebuilding — the rspec hook resets it each time.
       def built_router
-        @built_router ||= Router.new(supergraph: supergraph!, subgraphs: @router && @router[:subgraphs])
+        @built_router ||= Router.new(
+          supergraph: supergraph!,
+          subgraphs: @router && @router[:subgraphs],
+          fake: (@router && @router[:fake]) || {},
+        )
       end
 
       # The composed supergraph :router plans against — named, or the
       # conventional dump when that's what it is. A client can't supply
       # one: its schema is the API schema a router serves, with the
       # @join__* routing table stripped out.
-      def supergraph!
+      private def supergraph!
         return @router[:supergraph] if @router&.key?(:supergraph)
 
         path = GraphWeaver::SchemaLoader.locate_path
@@ -175,7 +175,7 @@ module GraphWeaver
         # explicit_schema, not schema: the latter falls back to the committed
         # dump, which loads as an anonymous GraphQL::Schema subclass — runnable
         # by every test that matters, and holding not one resolver.
-        runnable(explicit_schema) || GraphWeaver.live_schema ||
+        runnable(explicit_schema) || GraphWeaver::Internal::Util.live_schema ||
           raise(GraphWeaver::Error, ":in_process runs your resolvers, so it needs the live " \
             "GraphQL::Schema class — and GraphWeaver.client isn't running one in-process to " \
             "borrow. Name it in the example — graphql_in_process(MySchema) — or set " \
@@ -219,81 +219,32 @@ module GraphWeaver
         yield config
         # a typo'd override key pins nothing and the test still passes, so
         # catch it here — while the block that set it is still on the stack
-        validate_overrides!(config.explicit_schema, config.overrides) if config.explicit_schema
+        Internal::Overrides.validate!(config.explicit_schema, config.overrides) if config.explicit_schema
         config
       end
 
-      # Override keys name schema coordinates: "Type.field", or a bare field
-      # name matching that field on any type. Anything else is a typo that
-      # would silently fabricate random data instead of pinning a value.
-      def validate_overrides!(schema, overrides)
-        overrides.each_key { |key| validate_override_key!(schema, key.to_s) }
-      end
-
       # back to defaults — between tests, or to undo an experiment
       def reset!
         @config = nil
       end
 
       # resolve a cassette name ("github") against cassette_dir; paths
-      # with separators or extensions pass through
+      # with separators or extensions name the file themselves
       def cassette_path(name)
-        return name if name.include?("/") || name.end_with?(".yml", ".yaml")
+        return Internal::Util.resolve(name) if name.include?("/") || name.end_with?(".yml", ".yaml")
 
         File.join(cassette_dir, "#{name}.yml")
       end
 
-      # The configured directory, against Rails.root when there is one — a rake
-      # task runs from wherever it runs from; the cassettes don't move.
-      # const_get rather than a bare Rails: sorbet can't resolve a constant the
-      # gem doesn't depend on.
-      def cassette_dir
-        dir = config.cassette_dir
-        root = (Object.const_get(:Rails).root if Object.const_defined?(:Rails))
-        root ? File.join(root.to_s, dir) : dir
-      rescue NoMethodError
-        dir # something else named Rails
-      end
-
-      private
-
-      def validate_override_key!(schema, key)
-        type_name, field_name = key.split(".", 2)
-        # introspection fields (__typename) are real but absent from #fields
-        return if (field_name || type_name).start_with?("__")
-
-        if field_name.nil?
-          known = field_names(schema)
-          return if known.include?(type_name)
-
-          bad_override!(key, "matches no field in this schema", known, type_name)
-        end
-
-        type = schema.get_type(type_name)
-        unless type.respond_to?(:fields)
-          bad_override!(key, "names no object type in this schema", schema.types.keys, type_name)
-        end
-        return if type.fields.key?(field_name)
-
-        bad_override!(key, "is not a field of #{type_name}", type.fields.keys, field_name)
-      end
-
-      def bad_override!(key, problem, dictionary, term)
-        suggestion = GraphWeaver.did_you_mean(dictionary, term)
-        hint = suggestion ? " — did you mean '#{suggestion}'?" : ""
-        raise GraphWeaver::Error, "override key #{key.inspect} #{problem}#{hint}"
-      end
-
-      # Every output field name in the schema — walked only when a bare key
-      # asks for it.
-      def field_names(schema)
-        schema.types.each_value.flat_map { |type| type.respond_to?(:fields) ? type.fields.keys : [] }.uniq
-      end
+      # The configured directory as a real path — a rake task or an rspec run
+      # starts from wherever it starts from; the cassettes don't move.
+      def cassette_dir = Internal::Util.resolve(config.cassette_dir)
     end
   end
 end
 
-require_relative "testing/values"
+require_relative "internal/overrides"
+require_relative "internal/values"
 require_relative "testing/fake_client"
 require_relative "testing/fake_subgraph"
 require_relative "testing/failure"

data/lib/graph_weaver/transport/faraday.rb

@@ -61,7 +61,7 @@ module GraphWeaver
         # which adapter got picked decides socket reuse — Faraday's
         # default net_http one opens a connection per request. Naming it
         # is the cheapest way to make that discoverable.
-        GraphWeaver.log(:info) { "faraday transport #{@url} (adapter: #{@connection.builder.adapter})" }
+        GraphWeaver::Internal::Log.log(:info) { "faraday transport #{@url} (adapter: #{@connection.builder.adapter})" }
       end
 
       private

data/lib/graph_weaver/transport/http.rb

@@ -39,7 +39,18 @@ module GraphWeaver
         raise ArgumentError, "pool_size: must be >= 1" unless pool_size >= 1
 
         @url = url
-        @uri = URI(url)
+        # a scheme-less url parses as a *path* with no host, and the failure
+        # then lands as far away as Net::HTTP.start(nil, nil)
+        uri = begin
+          URI(url)
+        rescue URI::InvalidURIError
+          nil
+        end
+        unless uri && %w[http https].include?(uri.scheme)
+          raise ArgumentError, "expected an http(s) url, got #{url.inspect}"
+        end
+
+        @uri = uri
         @headers = headers
         @open_timeout = open_timeout
         @read_timeout = read_timeout
@@ -63,7 +74,7 @@ module GraphWeaver
         # live connections, LIFO — a warm socket beats opening a cold one,
         # so a single-threaded caller keeps reusing the same one
         @idle = []
-        @idle_lock = Mutex.new
+        @lock = Mutex.new # guards @idle and @saturated
       end
 
       private
@@ -84,12 +95,14 @@ module GraphWeaver
       # is the concurrency ceiling.
       def with_connection
         acquire_permit
-        http = nil
-
+        # nothing between acquiring the permit and the ensure that returns it:
+        # an async interrupt (Rack::Timeout, a fiber cancel) landing in that
+        # gap would leak a permit, shrinking the pool for the process's life
         begin
-          http = @idle_lock.synchronize { @idle.pop } || connect
+          http = nil
+          http = @lock.synchronize { @idle.pop } || connect
           result = yield http
-          @idle_lock.synchronize { @idle.push(http) }
+          @lock.synchronize { @idle.push(http) }
           result
         rescue Exception
           # socket state is unknown — drop it, leaving the slot empty so
@@ -107,14 +120,19 @@ module GraphWeaver
       # when idle past keep_alive_timeout, so a server-closed keep-alive
       # socket doesn't produce spurious failures.
       def connect
-        GraphWeaver.log(:debug) { "connecting to #{@uri.hostname}:#{@uri.port}" }
-        Net::HTTP.start(
+        GraphWeaver::Internal::Log.log(:debug) { "connecting to #{@uri.hostname}:#{@uri.port}" }
+        http = 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,
           **@ssl,
         )
+        # net/http otherwise returns the bytes that did arrive, so a
+        # connection dying mid-body reads as a server answering with garbage —
+        # a permanent ServerError — instead of the retriable EOFError it is
+        http.ignore_eof = false
+        http
       end
 
       # Take a permit, saying so when none is free. A queued request is
@@ -129,9 +147,8 @@ module GraphWeaver
         @permits.pop
         waited = ((Process.clock_gettime(Process::CLOCK_MONOTONIC) - started) * 1000).round
 
-        first = !@saturated
-        @saturated = true
-        GraphWeaver.log(first ? :warn : :debug) do
+        first = @lock.synchronize { !@saturated && (@saturated = true) }
+        GraphWeaver::Internal::Log.log(first ? :warn : :debug) do
           "connection pool saturated: waited #{waited}ms for 1 of #{@pool_size} connections to " \
             "#{@uri.hostname} — raise pool_size: to this process's concurrency"
         end
@@ -140,7 +157,7 @@ module GraphWeaver
       def disconnect(http)
         return unless http
 
-        GraphWeaver.log(:debug) { "dropping connection to #{@uri.hostname}:#{@uri.port}" }
+        GraphWeaver::Internal::Log.log(:debug) { "dropping connection to #{@uri.hostname}:#{@uri.port}" }
         http.finish if http.started?
       rescue IOError
         # already closed

data/lib/graph_weaver/transport.rb

@@ -5,6 +5,7 @@ require "json"
 require "sorbet-runtime"
 
 require_relative "errors"
+require_relative "internal"
 require_relative "version"
 
 # Base class for the bundled network transports — Transport::HTTP
@@ -48,10 +49,10 @@ class GraphWeaver::Transport
   # slow-query reports on. Generated modules pass their OPERATION_NAME;
   # a raw query string falls back to the name in the document itself.
   def execute(query, variables: {}, operation_name: nil)
-    operation_name ||= GraphWeaver::Transport.operation_name(query)
+    operation_name ||= GraphWeaver::Internal::Wire.operation_name(query)
     payload = { url:, operation: operation_name }
 
-    GraphWeaver.instrument(GraphWeaver::EXECUTE_EVENT, payload) do
+    GraphWeaver::Internal::Log.instrument(GraphWeaver::EXECUTE_EVENT, payload) do
       perform(query, variables, operation_name, payload)
     end
   end
@@ -61,11 +62,13 @@ class GraphWeaver::Transport
   private def perform(query, variables, operation_name, payload)
     # tag pairs this request's log lines (threads interleave), and names
     # the operation so the log says WHICH query, not just the url
-    tag = GraphWeaver.logger && GraphWeaver::Transport.log_tag(operation_name)
+    tag = GraphWeaver.logger && GraphWeaver::Internal::Wire.log_tag(operation_name)
 
-    # full query + variables at debug only — they can carry PII
-    GraphWeaver.log(:debug) do
-      "POST #{url} #{tag} variables=#{JSON.generate(variables)}\n#{GraphWeaver::Transport.truncate_for_log(query)}"
+    # full query + variables at debug only — they can carry PII, and the
+    # sensitive keys are scrubbed even there (GraphWeaver.filter_parameters)
+    GraphWeaver::Internal::Log.log(:debug) do
+      filtered = JSON.generate(GraphWeaver::Internal::Log.filter_variables(variables))
+      "POST #{url} #{tag} variables=#{filtered}\n#{GraphWeaver::Internal::Wire.truncate_for_log(query)}"
     end
 
     # camelCase because it's the graphql-over-http request field, not a
@@ -84,7 +87,7 @@ class GraphWeaver::Transport
     # headers is optional: a third-party subclass returning the
     # documented [status, body] pair simply has none
     status, body, headers = begin
-      GraphWeaver.log_timed(:debug, "POST #{url} #{tag} completed") do
+      GraphWeaver::Internal::Log.log_timed(:debug, "POST #{url} #{tag} completed") do
         post(encoded)
       end
     rescue *GraphWeaver.transport_errors.to_a => e
@@ -93,7 +96,7 @@ class GraphWeaver::Transport
     end
 
     payload[:status] = status
-    GraphWeaver.log(:debug) { "HTTP #{status} #{tag} from #{url} (#{body.to_s.bytesize} bytes)" }
+    GraphWeaver::Internal::Log.log(:debug) { "HTTP #{status} #{tag} from #{url} (#{body.to_s.bytesize} bytes)" }
 
     parsed = parse_body(body)
 
@@ -139,32 +142,6 @@ class GraphWeaver::Transport
   end
   alias to_s inspect
 
-  # The name of the document's FIRST operation, nil when anonymous. Only
-  # the fallback for a raw query string handed straight to a transport —
-  # generated modules pass their OPERATION_NAME, parsed properly.
-  OPERATION_NAME_PATTERN = /\A\s*(?:query|mutation|subscription)\s+([A-Za-z_]\w*)/
-  def self.operation_name(query)
-    query[OPERATION_NAME_PATTERN, 1]
-  end
-
-  # "[req 3 FilteredPokemon]" — a per-process request id plus the
-  # operation name, when there is one
-  REQUEST_MUTEX = Mutex.new
-
-  def self.log_tag(operation_name = nil)
-    id = REQUEST_MUTEX.synchronize { @request_count = (@request_count || 0) + 1 }
-    "[req #{id}#{" #{operation_name}" if operation_name}]"
-  end
-
-  # keep debug readable: a 100-line introspection query would drown the
-  # log — the INFO introspection line already carries the timing
-  LOG_QUERY_LIMIT = 600
-  def self.truncate_for_log(query)
-    return query if query.length <= LOG_QUERY_LIMIT
-
-    "#{query[0, LOG_QUERY_LIMIT]}... (truncated, #{query.bytesize} bytes total)"
-  end
-
   private
 
   # POST the JSON body to the endpoint; return [status code, raw body]

data/lib/graph_weaver/version.rb

@@ -1,3 +1,3 @@
 module GraphWeaver
-  VERSION = "0.5.1"
+  VERSION = "0.6.0"
 end