graph_weaver 0.7.3 → 0.7.5

data/lib/graph_weaver/schema_loader.rb

@@ -887,9 +887,10 @@ module GraphWeaver::SchemaLoader
     return recompose_hint(path) if composed_dump?(path)
 
     missing = path ? "#{path} records no source url" : "no schema dump at #{GraphWeaver.schema_path}"
-    "#{missing} — pass one: rake graph_weaver:schema:refresh URL=https://api.example.com/graphql " \
-      "(if this app serves the schema itself, point GraphWeaver.client at the class and the dump is " \
-      "rebuilt from it — see docs/getting_started.md#your-apps-own-schema-in-process)"
+    "#{missing} — pass one: rake graph_weaver:schema:refresh " \
+      "URL=https://api.example.com/graphql, or point the graph's client at the server — an app " \
+      "that serves the schema itself points GraphWeaver.client at the class and the dump is built " \
+      "from that (docs/getting_started.md#your-apps-own-schema-in-process)"
   end
   private_class_method :refresh_hint
 
@@ -922,11 +923,9 @@ module GraphWeaver::SchemaLoader
   # ends up honoured in some places and not others.
   def self.source_transport(path)
     meta = provenance(path)
-    unless meta&.key?("url")
-      raise GraphWeaver::Error,
-        "#{path} records no source url — it wasn't introspected from one. Pass transport:, " \
-        "or rebuild it from the schema class that produced it."
-    end
+    # the same sentence refresh! gives: this is reached by typing a rake task
+    # (schema:diff), and `transport:` is not something a rake user can pass
+    raise GraphWeaver::Error, refresh_hint(path) unless meta&.key?("url")
 
     GraphWeaver.new(meta["url"], auth: ENV[auth_env(path)]).transport
   end

data/lib/graph_weaver/tasks.rb

@@ -170,6 +170,30 @@ module GraphWeaver
         }.filter_map { |kind, names| "  #{kind}: #{names.sort.join(", ")}" if names.any? }
       end
 
+      # What `queries:check` just answered. It re-introspects the url a dump
+      # records and asks a live class directly; anything else it checks as it
+      # stands on disk, which is `verify`'s question — and both exited 0
+      # saying "against the schema".
+      def self.validated
+        dumps = GraphWeaver.graphs.filter_map { |graph| as_committed(graph) }
+        return "every query validates against the schema" if dumps.empty?
+
+        "every query validates against #{dumps.join(", ")} as committed — not the server " \
+          "(rake graph_weaver:schema:diff asks whether the server moved)"
+      end
+
+      # A graph whose queries were checked against the file rather than the
+      # server: a graph that names its own schema is checked against exactly
+      # that, and a dump with no recorded url has nothing to re-read.
+      def self.as_committed(graph)
+        path = graph.dump_path
+        return unless path && graph.live_schema.nil?
+        return if !graph.named_schema? && GraphWeaver::SchemaLoader.provenance(path)&.key?("url")
+
+        GraphWeaver::Internal::Util.relative(path)
+      end
+      private_class_method :as_committed
+
       # Neither task that needs the committed dump can take one itself, so both
       # say which task can — the same sentence SchemaLoader gives on refresh.
       def self.no_dump
@@ -184,7 +208,23 @@ module GraphWeaver
       # rewrites it from the graph's source, `diff` says how far that source
       # has drifted from it, whichever the source is. A graph whose schema IS
       # a live class reads no dump at all, so it has neither.
-      def self.dumps = GraphWeaver.graphs.map { |graph| [graph, graph.dump_path, graph.dump_source] }
+      #
+      # The dump's own record of where it came from first, then the client the
+      # graph's modules already call: a dump inherited with no provenance, or a
+      # schema kept by hand, still has a server behind it, and refusing one
+      # took every other graph's refresh down with it.
+      def self.dumps
+        GraphWeaver.graphs.map { |graph| [graph, graph.dump_path, graph.dump_source || graph.client_url] }
+      end
+
+      # A dump with no recorded url whose graph names no client: nothing
+      # behind the file to re-read, so the file is the schema. Said and
+      # stepped over rather than refused — the task's job is the graphs it
+      # CAN refresh.
+      def self.no_source(path)
+        "#{GraphWeaver::Internal::Util.relative(path)} records no source url and the graph names " \
+          "no client — left as checked in"
+      end
 
       # A graph that generates straight from a schema class has no dump
       # between the code and the output — so there is nothing here to
@@ -202,6 +242,19 @@ module GraphWeaver
         "#{whose} generates from #{source_name(source)} directly — no dump to keep in step"
       end
 
+      # What `diff` re-introspects for one graph. A schema class answers
+      # introspection itself. A url the dump recorded is left to
+      # SchemaLoader.diff, which builds the transport and so honours the
+      # auth_env the dump named. A source that came from the graph's client
+      # instead is that client's own transport — headers, auth and all.
+      def self.diff_transport(graph, source)
+        return source if source.is_a?(Module)
+        return if graph.dump_source
+
+        client = graph.client || GraphWeaver.client
+        client.respond_to?(:transport) ? client.transport : client
+      end
+
       # How a dump's source reads in a report: a url as itself, a schema
       # class by name.
       def self.source_name(source) = source.is_a?(Module) ? GraphWeaver::SchemaLoader.endpoint(source) : source
@@ -350,9 +403,8 @@ namespace :graph_weaver do
         # dump between the code and the output, so nothing can be stale
         next puts GraphWeaver::Internal::Tasks.no_dump_needed(graph, source) unless path
 
-        # a schema class answers introspection itself; left nil, diff builds
-        # the dump's own transport, auth and all
-        diff = GraphWeaver::SchemaLoader.diff(path, transport: (source if source.is_a?(Module)))
+        diff = GraphWeaver::SchemaLoader.diff(path,
+          transport: GraphWeaver::Internal::Tasks.diff_transport(graph, source))
         dump = GraphWeaver::Internal::Util.relative(path)
         next puts "#{dump} matches #{GraphWeaver::Internal::Tasks.source_name(source)}" if diff.empty?
 
@@ -398,6 +450,9 @@ namespace :graph_weaver do
         # below and refresh! bootstraps its first dump (or says how).
         path ||= graph.named_dump_path
         next puts GraphWeaver::Internal::Tasks.no_dump_needed(graph, source) if !path && graph.named_schema?
+        # a supergraph has no source by construction — nothing serves one —
+        # and refresh! answers that with "recompose", which is not a skip
+        next puts GraphWeaver::Internal::Tasks.no_source(path) if path && !source && !graph.supergraph
 
         written, from = GraphWeaver::SchemaLoader.refresh!(url: (source unless source.is_a?(Module)),
           schema: (source if source.is_a?(Module)), path:)
@@ -425,7 +480,7 @@ namespace :graph_weaver do
       # block-buffered stdout, so a piped CI log shows the verdict first
       $stdout.flush
       abort "#{failures.size} invalid #{(failures.size == 1) ? "query" : "queries"}" if failures.any?
-      puts "every query validates against the schema"
+      puts GraphWeaver::Internal::Tasks.validated
     end
   end
 

data/lib/graph_weaver/testing/fake_client.rb

@@ -137,12 +137,6 @@ class GraphWeaver::Testing::FakeClient
     null_chance: nil, errors: nil, fail_at: nil, corrupt: nil,
   }.freeze
 
-  # JSON's own types are already on the wire: at a leaf they skip the
-  # registry's serializer (Values#wire), and at a composite position (a Hash
-  # aside, which is response keys) they pin the field as written — nil is
-  # null, the rest is the corrupt payload the example asked for.
-  WIRE = GraphWeaver::Internal::Values::WIRE
-
   # Methods every Ruby object answers aren't fields: a schema does have a
   # `hash` or a `count`, and a Struct answers both with plausible nonsense
   # where fabricating is right.
@@ -151,7 +145,7 @@ class GraphWeaver::Testing::FakeClient
   # The scalars the GraphQL spec serializes as JSON strings, whatever Ruby
   # holds them.
   STRING_SCALARS = %w[ID String].freeze
-  private_constant :OPTIONS, :WIRE, :RUBY_OWN, :STRING_SCALARS
+  private_constant :OPTIONS, :RUBY_OWN, :STRING_SCALARS
 
   def initialize(pins = {}, **options)
     config = GraphWeaver::Testing.config
@@ -467,7 +461,9 @@ class GraphWeaver::Testing::FakeClient
   # reads them off — a FactoryBot build, a model, a Struct. Either way it
   # MERGES: what it doesn't answer is fabricated.
   def pinned_object(type, selections, value, source)
-    return value if !value.is_a?(Hash) && wire?(value)
+    # what JSON already holds is the pin as written — nil is null, and the rest
+    # is the corrupt payload the example asked for (a Hash is response keys)
+    return value if !value.is_a?(Hash) && GraphWeaver::Internal::Values.wire?(value)
 
     concrete = pinned_type(type, value, source)
     pins = value.is_a?(Hash) ? value : read_fields(concrete, selections, value)
@@ -497,8 +493,6 @@ class GraphWeaver::Testing::FakeClient
     object.respond_to?(name) && !RUBY_OWN.include?(object.method(name).owner)
   end
 
-  def wire?(value) = WIRE.any? { |klass| value.is_a?(klass) }
-
   # An object pin holds Ruby values — a Time, a Money, a T::Enum — where the
   # wire holds what the registration says they serialize to. A value that
   # is already wire-shaped is taken as written.

data/lib/graph_weaver/testing/router.rb

@@ -326,11 +326,14 @@ module GraphWeaver
 
         plan = @planner.plan(document, operation_name:)
         return introspect(query, variables, plan.operation_name) if plan.introspection
+        # read once, so every hop runs as the identity the query started
+        # with, whatever writes #context= while it is in flight
+        context = Internal::Util.context!(@context)
         # one subgraph answers the whole thing: hand it the document as
         # written, so nothing is rewritten that didn't have to be
-        return fetch(plan.entry, query, variables, plan.operation_name) if plan.verbatim
+        return fetch(plan.entry, query, variables, plan.operation_name, context) if plan.verbatim
 
-        run(plan, variables)
+        run(plan, variables, context)
       end
 
       # never leak the context (tokens, current_user) through logs or errors
@@ -374,7 +377,7 @@ module GraphWeaver
 
       # ---- execution ----------------------------------------------------
 
-      def run(plan, variables)
+      def run(plan, variables, context)
         errors = []
         data = {}
         # An operation's declared defaults are part of the variables, and
@@ -384,7 +387,7 @@ module GraphWeaver
           .merge(variables.to_h { |name, value| [name.to_s, value] })
 
         plan.steps.each do |step|
-          result = fetch_step(step, plan.operation, given)
+          result = fetch_step(step, plan.operation, given, context)
           Array(result["errors"]).each { |error| errors << rewrite(error, step.subgraph) }
           payload = result["data"]
           if payload.nil?
@@ -397,7 +400,7 @@ module GraphWeaver
           end
         end
 
-        plan.steps.each { |step| stitch(step, [[data, []]], plan.operation, given, errors) }
+        plan.steps.each { |step| stitch(step, [[data, []]], plan.operation, given, context, errors) }
 
         # A stitched fetch can leave a null where the composed schema says
         # non-null, and nothing re-applies GraphQL's propagation rules over a
@@ -443,7 +446,7 @@ module GraphWeaver
       # Everything the plan applies at this level: one _entities fetch per
       # subgraph the level defers to (all nodes at once — _entities answers
       # in representation order), then the same again one level down.
-      def stitch(step, nodes, operation, variables, errors)
+      def stitch(step, nodes, operation, variables, context, errors)
         return if nodes.empty?
 
         # An abstract position: the plan holds one branch per concrete type
@@ -454,12 +457,12 @@ module GraphWeaver
         if step.is_a?(Internal::Planner::Branches)
           step.steps.each do |type_name, branch|
             stitch(branch, nodes.select { |(node, _)| node[TYPENAME] == type_name },
-              operation, variables, errors)
+              operation, variables, context, errors)
           end
           return
         end
 
-        blocked = prefetch(step, nodes, operation, variables, errors)
+        blocked = prefetch(step, nodes, operation, variables, context, errors)
 
         # A fetch for a selection the operation excluded is a fetch a real
         # router never makes, and `trace` is something specs assert on. The
@@ -478,7 +481,8 @@ module GraphWeaver
 
           entities = []
           if fetched.any?
-            result = entities_fetch(target, step.type_name, deferrals.map(&:node), representations, operation, variables)
+            result = entities_fetch(target, step.type_name, deferrals.map(&:node), representations, operation,
+              variables, context)
             entities = result.dig("data", "_entities") || []
             Array(result["errors"]).each { |error| errors << rewrite(error, target, fetched) }
           end
@@ -502,12 +506,12 @@ module GraphWeaver
           deferrals.each do |deferral|
             next unless deferral.step
 
-            stitch(deferral.step, descend(nodes, deferral.response_key), operation, variables, errors)
+            stitch(deferral.step, descend(nodes, deferral.response_key), operation, variables, context, errors)
           end
         end
 
         step.children.each do |key, child|
-          stitch(child, descend(nodes, key), operation, variables, errors)
+          stitch(child, descend(nodes, key), operation, variables, context, errors)
         end
 
         nodes.each { |(node, _)| strip!(node, step) }
@@ -517,7 +521,7 @@ module GraphWeaver
       # keys before the fetch whose representation carries them. Returns the
       # nodes the holding subgraph didn't recognize: their required fields
       # don't exist, so nothing depending on them can resolve.
-      def prefetch(step, nodes, operation, variables, errors)
+      def prefetch(step, nodes, operation, variables, context, errors)
         blocked = []
         # the field it feeds was excluded, so this is a fetch a real router
         # never makes — and a test double that runs a resolver production
@@ -533,7 +537,7 @@ module GraphWeaver
           selections = Internal::Planner.injected_selections(group.flat_map(&:paths).uniq)
           roots = selections.map(&:alias)
 
-          result = entities_fetch(subgraph, step.type_name, selections, representations, operation, variables)
+          result = entities_fetch(subgraph, step.type_name, selections, representations, operation, variables, context)
           entities = result.dig("data", "_entities") || []
           Array(result["errors"]).each { |error| errors << rewrite(error, subgraph, nodes) }
 
@@ -621,16 +625,16 @@ module GraphWeaver
         Array(path).map { |segment| segment.is_a?(String) ? segment.delete_prefix(PREFIX) : segment }
       end
 
-      def fetch_step(step, operation, variables)
+      def fetch_step(step, operation, variables, context)
         document = GraphQL::Language::Nodes::OperationDefinition.new(
           operation_type: operation.operation_type || "query",
           variables: used_variables(step.selections, operation),
           selections: step.selections,
         )
-        run_subgraph(step.subgraph, document, variables)
+        run_subgraph(step.subgraph, document, variables, context)
       end
 
-      def entities_fetch(subgraph, type_name, nodes, representations, operation, variables)
+      def entities_fetch(subgraph, type_name, nodes, representations, operation, variables, context)
         entities = GraphQL::Language::Nodes::Field.new(
           name: "_entities",
           arguments: [GraphQL::Language::Nodes::Argument.new(
@@ -647,7 +651,7 @@ module GraphWeaver
           variables: [REPRESENTATIONS_DEFINITION] + used_variables(nodes, operation),
           selections: [entities],
         )
-        run_subgraph(subgraph, document, variables.merge(REPRESENTATIONS => representations))
+        run_subgraph(subgraph, document, variables.merge(REPRESENTATIONS => representations), context)
       end
 
       REPRESENTATIONS = "representations"
@@ -682,12 +686,12 @@ module GraphWeaver
         end
       end
 
-      def run_subgraph(subgraph, document, variables)
+      def run_subgraph(subgraph, document, variables, context)
         declared = document.variables.map(&:name)
-        fetch(subgraph, document.to_query_string, variables.slice(*declared), nil)
+        fetch(subgraph, document.to_query_string, variables.slice(*declared), nil, context)
       end
 
-      def fetch(name, query, variables, operation_name)
+      def fetch(name, query, variables, operation_name, context)
         faked = @faked.include?(name)
         entry = { subgraph: name, query:, variables: variables.to_h }
         entry[:faked] = true if faked
@@ -701,14 +705,12 @@ module GraphWeaver
         end
 
         GraphWeaver::Internal::Log.log(:debug) do
-          "router -> #{name} #{tag} variables=#{JSON.generate(GraphWeaver::Internal::Log.filter_variables(variables))}
-" \
+          "router -> #{name} #{tag} variables=#{JSON.generate(GraphWeaver::Internal::Log.filter_variables(variables))}\n" \
             "#{GraphWeaver::Internal::Wire.truncate_for_log(query)}"
         end
 
         GraphWeaver::Internal::Log.log_timed(:debug, "router -> #{name} #{tag} completed") do
-          @subgraphs.fetch(name).execute(query, variables:, operation_name:,
-            context: Internal::Util.context!(@context)).to_h
+          @subgraphs.fetch(name).execute(query, variables:, operation_name:, context:).to_h
         end
       end
 
@@ -783,7 +785,6 @@ module GraphWeaver
         end
         ordered
       end
-
     end
   end
 end

data/lib/graph_weaver/testing.rb

@@ -352,7 +352,6 @@ module GraphWeaver
       def runnable(schema)
         schema if schema.is_a?(Class) && schema <= GraphQL::Schema
       end
-
     end
 
     class << self
@@ -388,6 +387,107 @@ module GraphWeaver
       # 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)
+
+      # Whether a scalar's two definitions agree: the server's
+      # coerce_input/coerce_result, and your register_scalar. No schema
+      # carries the server's half — a scalar's SDL is its name and a url —
+      # so nothing `verify`, `schema:diff` or `generate` reads can say. A
+      # schema CLASS carries both, and this runs them against each other.
+      #
+      # Per scalar the schema declares and your app registered: fabricate a
+      # value the way :fake does, cast it, send it back out through
+      # `serialize:`, through the server's `coerce_input` and `coerce_result`,
+      # and back through `cast:`. Raises naming every scalar that disagreed
+      # and how; silent when they all agree.
+      #
+      # Pass the schema CLASS. A dump's scalars pass values through, so
+      # against one this checks only that a registration's `cast:` accepts
+      # what its own `serialize:` writes — which is worth knowing, and is not
+      # the same question.
+      #
+      # The fabricated value is what the check has to work with, so pin the
+      # one that matters where it matters —
+      # `config.overrides = { "Decimal" => "123456789.123456789" }` is how
+      # the precision case gets exercised at all.
+      def check_scalars!(schema)
+        registry = Internal::Util.registry_for(schema)
+        values = Internal::Values.new(seed: 0, schema:, registry:)
+        context = GraphQL::Query.new(schema, "{ __typename }").context
+
+        disagreed = schema.types.values.sort_by(&:graphql_name).filter_map do |type|
+          next unless type.kind.name == "SCALAR"
+          # the built-in entries are the library's own; it is your
+          # registration that can be wrong about this server
+          next if registry.builtin_scalar?(type.graphql_name) ||
+            !registry.scalar_registry.key?(type.graphql_name)
+
+          disagreement(registry.scalar(type.graphql_name), type, values, context)
+        end
+        return if disagreed.empty?
+
+        raise GraphWeaver::Error, "#{disagreed.size} scalar(s) disagree with #{schema}:\n" +
+          disagreed.map { |line| "  #{line}" }.join("\n")
+      end
+
+      private
+
+      # One scalar's verdict, or nil when the two halves agree. Each step is
+      # a different mistake, so each says which.
+      def disagreement(scalar, type, values, context)
+        name = type.graphql_name
+        # a scalar registered as your own class has no fabricable value, and
+        # it says how to pin one — reported here rather than raised, so one
+        # unpinned scalar doesn't hide the verdict on all the others
+        begin
+          wire = values.scalar(name, name)
+        rescue GraphWeaver::Error => e
+          return "#{name}: #{e.message}"
+        end
+
+        cast = cast_proc(scalar)
+        begin
+          sample = cast.call(wire)
+        rescue StandardError => e
+          return "#{name}: cast: can't read #{wire.inspect}, the value fabricated for it (#{e.message}) " \
+            "— pin the form this server sends: overrides: { #{name.inspect} => ... }"
+        end
+
+        if scalar.serialize? && !scalar.serialize_value?
+          return "#{name}: serialize: is a Proc, which builds source for the generated file rather " \
+            "than converting a value, so there is nothing here to run it against"
+        end
+
+        out = scalar.serialize_value(sample)
+        refused = "#{name}: the server refused #{out.inspect}, the wire form serialize: writes"
+        begin
+          received = type.coerce_input(out, context)
+        rescue StandardError => e
+          return "#{refused} (#{e.message})"
+        end
+        return "#{refused} (coerce_input returned nil)" if received.nil? && !out.nil?
+
+        result = type.coerce_result(received, context)
+        begin
+          back = cast.call(result)
+        rescue StandardError => e
+          return "#{name}: cast: refused #{result.inspect}, the result form the server's " \
+            "coerce_result writes (#{e.message})"
+        end
+        return if back == sample
+
+        "#{name}: round-trips lossily — sent #{Internal::Redact.spell(sample)}, got back #{Internal::Redact.spell(back)}"
+      end
+
+      # The registration's `cast:`, RUN rather than emitted. A cast builds
+      # SOURCE for the generated file, so evaluating it is the only way to
+      # run one — at the top level, where a generated file's own constants
+      # resolve from.
+      def cast_proc(scalar)
+        source = scalar.cast("wire")
+        return ->(wire) { wire } if source.nil?
+
+        eval("->(wire) { #{source} }", TOPLEVEL_BINDING, __FILE__, __LINE__) # rubocop:disable Security/Eval
+      end
     end
   end
 end

data/lib/graph_weaver/version.rb

@@ -1,3 +1,3 @@
 module GraphWeaver
-  VERSION = "0.7.3"
+  VERSION = "0.7.5"
 end