graph_weaver 0.7.3 → 0.7.4

data/lib/graph_weaver/testing.rb

@@ -388,6 +388,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 #{sample.inspect}, got back #{back.inspect}"
+      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.4"
 end

data/lib/graph_weaver.rb

@@ -29,7 +29,11 @@ module GraphWeaver
   # How far into a file to look for it: the header sits under the `typed:` and
   # `frozen_string_literal:` magic comments, never deeper.
   HEADER_SCAN_LINES = 10
-  private_constant :GENERATED_HEADER, :HEADER_SCAN_LINES
+
+  # Where a graph declares the modules its extend_type blocks mint — an .rbi,
+  # so the declaration reaches `srb tc` and nothing else (see helpers_rbi).
+  HELPERS_RBI = "type_helpers.rbi"
+  private_constant :GENERATED_HEADER, :HEADER_SCAN_LINES, :HELPERS_RBI
 
   class << self
     # A client for one GraphQL server — transport, schema, and scoped
@@ -484,12 +488,13 @@ module GraphWeaver
     end
     private :orphaned
 
-    # Every .rb under output that GraphWeaver wrote, identified by the header
+    # Every file under output that GraphWeaver wrote, identified by the header
     # it emits. The header — not a *_query.rb glob — is what makes pruning
     # safe: this is a real directory, and a hand-written file in it must
-    # survive regeneration.
+    # survive regeneration. .rbi too: a stale type-helper declaration would
+    # keep an app's srb tc green over an include that is gone.
     def generated_files(output)
-      Dir[File.join(Internal::Util.resolve(output), "**/*.rb")].sort.select do |path|
+      Dir[File.join(Internal::Util.resolve(output), "**/*.{rb,rbi}")].sort.select do |path|
         File.foreach(path).first(HEADER_SCAN_LINES).any? { |line| line.start_with?(GENERATED_HEADER) }
       end
     end
@@ -618,6 +623,9 @@ module GraphWeaver
     # (products, reviews)", plus a "subgraphs" key — since knowing whose
     # code to look at is half the answer. A plain schema is unaffected.
     #
+    # One query you have as a *string* is Client#check_query — the same
+    # entries, against that client's own schema.
+    #
     # A different question from verify_generated!, which asks whether the
     # committed Ruby matches the committed schema. `rake
     # graph_weaver:queries:check` prints this and exits non-zero.
@@ -628,7 +636,7 @@ module GraphWeaver
         checked = checked_schema(graph)
         table = checked_routing_table(graph)
         Internal::Util.query_files(graph.queries).each do |path|
-          errors = validation_errors(checked, File.read(path), shared, table)
+          errors = Internal::QueryCheck.errors(checked, File.read(path), shared, table)
           next if errors.empty?
 
           # keyed by file, as it has always been — and two graphs may share a
@@ -647,20 +655,11 @@ module GraphWeaver
     def checked_schema(graph) = graph.named_schema? ? graph.schema : refreshed_schema
     private :checked_schema
 
-    # The routing table behind the schema check_queries is about to use,
-    # when there is one: a composed supergraph dump says who resolves what,
-    # so a validation error can name the subgraph whose code to look at. nil
-    # for every other source — a plain schema is entirely unaffected — and
-    # nil when a live schema class is what gets checked, since the dump then
-    # isn't what the errors came from.
+    # The routing table behind the schema check_queries is about to use, when
+    # there is one — nil when a live schema class is what gets checked, since
+    # the dump then isn't what the errors came from.
     def checked_routing_table(graph)
-      return if graph.live_schema
-
-      path = graph.dump_path
-      return unless path&.end_with?(".graphql", ".gql")
-
-      sdl = File.read(path)
-      SchemaLoader.routing_table(sdl) if SchemaLoader.federation_sdl?(sdl)
+      Internal::QueryCheck.routing_table_for(graph.dump_path) unless graph.live_schema
     end
     private :checked_routing_table
 
@@ -686,53 +685,6 @@ module GraphWeaver
     end
     private :refreshed_schema
 
-    # One query's schema-validation errors as JSON-ready hashes, with the
-    # source position graphql-ruby reports. Unparseable counts as an error
-    # too — it doesn't validate either, and inline_fragments (which parses
-    # first) has already branded it with its position.
-    def validation_errors(schema, source, shared, table = nil)
-      # path omitted: the caller keys the report by file, so branding the
-      # message with it too would just print the path twice
-      schema.validate(Codegen.inline_fragments(source, shared)).map do |error|
-        detail = error.to_h
-        location = detail["locations"]&.first || {}
-        subgraphs = table ? attribute(table, detail["extensions"]) : []
-        entry = {
-          "message" => subgraphs.empty? ? error.message : "#{error.message} (#{subgraphs.join(", ")})",
-          "line" => location["line"],
-          "column" => location["column"],
-        }
-        subgraphs.empty? ? entry : entry.merge("subgraphs" => subgraphs)
-      end
-    rescue GraphWeaver::QueryValidationError => e
-      # an unparseable query: codegen folds the position (and the file) into
-      # the message, and this report keeps them separate — same splitter the
-      # rendered error uses, so the two can't drift apart
-      e.errors.map do |detail|
-        _path, _position, message = QueryValidationError.split(detail)
-        detail.transform_keys(&:to_s).merge("message" => message)
-      end
-    end
-    private :validation_errors
-
-    # Which subgraphs a validation error is about, on a federated schema:
-    # "Field 'weight' doesn't exist on type 'Product'" is much less useful
-    # than the same line plus "(products)" — whose code to look at, whose
-    # team to talk to. graphql-ruby reports the coordinate structurally, so
-    # this is a lookup rather than message parsing. Both halves of the
-    # coordinate are required: an argument error reports typeName "Field"
-    # (the AST node kind, not a type), and looking that up would attribute
-    # confidently and wrongly.
-    def attribute(table, extensions)
-      return [] unless extensions
-
-      type_name, field_name = extensions.values_at("typeName", "fieldName")
-      return [] unless type_name && field_name
-
-      table.responsible(type_name, field_name)
-    end
-    private :attribute
-
     # 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):
@@ -863,6 +815,7 @@ module GraphWeaver
 
       used = { inputs: [], enums: [], mapped: [] }
       used_unions = []
+      helpers = []
       shared = Codegen.load_fragments(fragments)
 
       refusals = []
@@ -886,6 +839,7 @@ module GraphWeaver
         codegen.variable_type_names.each { |kind, names| used[kind] |= names }
         found.concat(codegen.untyped_scalars).uniq!
         used_unions |= codegen.used_union_names
+        helpers |= codegen.block_helpers
         [filename, out]
       rescue GraphWeaver::Error => e
         # collected, not raised: nothing is written either way, and an adopter
@@ -903,16 +857,52 @@ module GraphWeaver
           unions: used_unions, fragments: shared,
         )
         found.concat(codegen.untyped_scalars).uniq!
+        helpers |= codegen.block_helpers
         # these land in the graph's output like any other file, so they collide
         # with another graph's the same way
         types.each_key { |filename| refuse_duplicate_file!(seen, filename, graph, graph.types_module) }
         plan = types.to_a + plan
       end
 
+      if helpers.any?
+        refuse_duplicate_file!(seen, HELPERS_RBI, graph, "the extend_type blocks")
+        plan = [[HELPERS_RBI, helpers_rbi(helpers)]] + plan
+      end
+
       plan
     end
     private :generation_plan
 
+    # One rule: generation declares every constant it includes. A block-form
+    # extend_type mints its mixin at registration, so no source file declares
+    # GraphWeaver::TypeHelpers::Pet — and an app's `srb tc` failed on every
+    # generated include of one ("Unable to resolve constant ...").
+    #
+    # An .rbi rather than Ruby, because Ruby never loads one: the include stays
+    # the only thing that resolves the constant at runtime, which keeps a
+    # dropped registration loud (see load_generated!) instead of silently
+    # handing the struct an empty module.
+    def helpers_rbi(names)
+      # `module A::B` does not define A, so each outer segment is opened first
+      declared = names.flat_map { |name|
+        segments = name.split("::")
+        (1...segments.size).map { |i| segments.first(i + 1).join("::") }
+      }.uniq.sort
+      # assembled line by line, not from a heredoc (as Emit does): a `# typed:`
+      # sigil at the start of a line is the sigil srb reads for THIS file
+      lines = [
+        "# typed: strict",
+        "",
+        "#{GENERATED_HEADER} #{VERSION} — do not edit. The modules this graph's",
+        "# extend_type blocks mint, declared so `srb tc` can resolve the includes",
+        "# in the generated code. Ruby never loads an .rbi; the registrations do",
+        "# the real work.",
+        "",
+      ]
+      (lines + declared.map { |mod| "module #{mod}; end" }).join("\n") + "\n"
+    end
+    private :helpers_rbi
+
     # Every query that refused, in one error. One refusal is re-raised as
     # itself, so a single bad file reads exactly as it always has — class,
     # message and all; several become one list, because clearing them a file
@@ -1054,8 +1044,18 @@ module GraphWeaver
     # strict), requires: names files the generated code should require.
     # Generation fails naming any schema value that doesn't resolve —
     # exhaustiveness checked ahead of runtime.
-    def register_enum(graphql_name, type, positional_map = nil, map: nil, fallback: nil, requires: nil)
-      Codegen.register_enum(graphql_name, type, positional_map, map:, fallback:, requires:)
+    #
+    # alias: says two of the schema's wire values are one value — both cast,
+    # the target is what goes back on the wire. It is the whole registration
+    # when there is no enum of your own to map onto, which is what a schema
+    # mid-rename needs:
+    #
+    #      GraphWeaver.register_enum("Status", alias: { "legacy_mode" => "LEGACY_MODE" })
+    def register_enum(graphql_name, type = nil, positional_map = nil, map: nil, fallback: nil, requires: nil,
+      alias: nil)
+      # `alias` is a Ruby keyword, so the parameter is only readable through binding
+      Codegen.register_enum(graphql_name, type, positional_map, map:, fallback:, requires:,
+        alias: binding.local_variable_get(:alias))
     end
 
     # Include app-owned helper modules into every struct generated from a

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: graph_weaver
 version: !ruby/object:Gem::Version
-  version: 0.7.3
+  version: 0.7.4
 platform: ruby
 authors:
 - Daniel Pepper
@@ -363,7 +363,7 @@ licenses:
 - MIT
 metadata:
   bug_tracker_uri: https://github.com/dpep/graph_weaver/issues
-  changelog_uri: https://github.com/dpep/graph_weaver/blob/v0.7.3/CHANGELOG.md
+  changelog_uri: https://github.com/dpep/graph_weaver/blob/v0.7.4/CHANGELOG.md
   documentation_uri: https://github.com/dpep/graph_weaver/tree/main/docs
   rubygems_mfa_required: 'true'
   source_code_uri: https://github.com/dpep/graph_weaver