graph_weaver 0.5.0 → 0.6.0

data/lib/graph_weaver/retry.rb

@@ -2,6 +2,7 @@
 # frozen_string_literal: true
 
 require_relative "errors"
+require_relative "transport"
 
 # Wraps any client/transport with configurable retries — it satisfies
 # the same execute contract, so it layers over HTTP, Faraday, or
@@ -9,16 +10,27 @@ require_relative "errors"
 #
 #      client = GraphWeaver::Retry.new(
 #        GraphWeaver::Transport::HTTP.new(url),
-#        tries: 5,                        # total attempts, first included
-#        on: [GraphWeaver::TransportError, GraphWeaver::ServerError],
+#        retries: 5,                      # attempts after the first
+#        retry_on: [GraphWeaver::TransportError, GraphWeaver::ServerError],
 #        backoff: :exponential,           # or :linear, or ->(attempt) { seconds }
-#        base: 0.5, max: 30,              # seconds; delays clamp at max:
+#        base_delay: 0.5, max_delay: 30,  # seconds; delays clamp at max_delay:
 #        jitter: true,                    # randomize each delay by 50-100%
 #        retry_codes: ["THROTTLED"],      # also retry GraphQL errors by code
+#        retry_mutations: true,           # off by default — see below
 #      )
 #
+# `retries:` is how many attempts follow the first; the other retry options
+# sit beside it — the same spelling on the client, which passes them
+# straight through (`GraphWeaver.new(url, retries: 5, backoff: :linear)`).
+# So `retries: 0` is one attempt and no retry.
+#
+# **A mutation gets one attempt.** A failure with no answer — a read
+# timeout, a 502, a reset socket — does not say whether the server applied
+# it, and a second `charge` is worse than a failed one. retry_mutations:
+# true opts an idempotent API back in.
+#
 # What retries, by default:
-#   - TransportError: always (the request never arrived)
+#   - TransportError: always
 #   - ServerError: 5xx, plus 408 and 429 — the rest of 4xx is a bug in
 #     the request, retrying won't fix it. Override with
 #     retry_if: ->(error) { ... }
@@ -26,9 +38,9 @@ require_relative "errors"
 #     default — pass the codes your API uses for transient failures)
 #
 # A server that answers with Retry-After sets the delay itself (clamped
-# to max:); otherwise the configured backoff decides.
+# to max_delay:); otherwise the configured backoff decides.
 #
-# Exhausting tries re-raises the last error (or returns the last
+# Exhausting the retries re-raises the last error (or returns the last
 # code-matched response).
 class GraphWeaver::Retry
   BACKOFFS = {
@@ -41,20 +53,26 @@ class GraphWeaver::Retry
   RETRIABLE_CLIENT_STATUSES = [408, 429].freeze
 
   # retry 5xx (and 408/429), not the rest of 4xx; everything else listed
-  # in on: retries
+  # in retry_on: retries
   DEFAULT_RETRY_IF = lambda do |error|
     !error.is_a?(GraphWeaver::ServerError) ||
       error.status >= 500 || RETRIABLE_CLIENT_STATUSES.include?(error.status)
   end
 
-  def initialize(client, tries: 3, on: [GraphWeaver::TransportError, GraphWeaver::ServerError],
-    backoff: :exponential, base: 0.5, max: 30, jitter: true, retry_if: DEFAULT_RETRY_IF,
-    retry_codes: [], sleeper: nil)
-    raise ArgumentError, "tries: must be >= 1" unless tries >= 1
+  # said once, where the decision is made and where it is explained
+  MUTATION_HINT = "not retrying a mutation — a request that failed without an answer " \
+    "may still have been applied; pass retry_mutations: true if yours are idempotent"
+  private_constant :DEFAULT_RETRY_IF, :MUTATION_HINT
+
+  def initialize(client, retries: 2, retry_on: [GraphWeaver::TransportError, GraphWeaver::ServerError],
+    backoff: :exponential, base_delay: 0.5, max_delay: 30, jitter: true, retry_if: DEFAULT_RETRY_IF,
+    retry_codes: [], retry_mutations: false, sleeper: nil)
+    raise ArgumentError, "retries: must be >= 0" unless retries.is_a?(Integer) && retries >= 0
 
     @client = client
-    @tries = tries
-    @on = on
+    @retries = retries
+    @retry_mutations = retry_mutations
+    @retry_on = retry_on
     @backoff = if backoff.is_a?(Proc)
       ->(_base, attempt) { backoff.call(attempt) } # custom: ->(attempt) { seconds }
     else
@@ -62,8 +80,8 @@ class GraphWeaver::Retry
         raise ArgumentError, "backoff: must be :exponential, :linear, or a Proc, got #{backoff.inspect}"
       }
     end
-    @base = base
-    @max = max
+    @base_delay = base_delay
+    @max_delay = max_delay
     @jitter = jitter
     @retry_if = retry_if
     @retry_codes = retry_codes
@@ -76,6 +94,7 @@ class GraphWeaver::Retry
   end
 
   def execute(query, variables: {}, operation_name: nil)
+    attempts = mutation?(query) ? 1 : @retries + 1
     attempt = 0
     failure = T.let(nil, T.nilable(Exception))
 
@@ -83,20 +102,33 @@ class GraphWeaver::Retry
       attempt += 1
       begin
         response = @client.execute(query, variables:, operation_name:)
-        return response unless attempt < @tries && retryable_response?(response)
-      rescue *@on => e
-        raise if attempt >= @tries || !@retry_if.call(e)
+        return response unless attempt < attempts && retryable_response?(response)
+      rescue *@retry_on => e
+        if attempt >= attempts || !@retry_if.call(e)
+          GraphWeaver::Internal::Log.log(:warn) { MUTATION_HINT } if attempts == 1 && @retries.positive?
+          raise
+        end
 
         failure = e
       end
 
-      @sleeper.call(delay(attempt, failure))
+      seconds = delay(attempt, failure)
+      # a retry is invisible otherwise: the caller sees one slow call, and the
+      # log shows an error that apparently didn't stop anything
+      GraphWeaver::Internal::Log.log(:info) do
+        "retrying #{operation_name || "query"} in #{seconds.round(2)}s (attempt #{attempt + 1} of #{attempts})"
+      end
+      @sleeper.call(seconds)
       failure = nil
     end
   end
 
   private
 
+  def mutation?(query)
+    !@retry_mutations && @retries.positive? && GraphWeaver::Internal::Wire.mutation?(query)
+  end
+
   def retryable_response?(response)
     return false if @retry_codes.empty?
 
@@ -107,12 +139,12 @@ class GraphWeaver::Retry
   def delay(attempt, failure)
     # A Retry-After wins over our backoff: the server is the only party
     # that knows when its window reopens, and it isn't guessing. Still
-    # clamped to max:, so "come back in an hour" can't park a thread for
+    # clamped to max_delay:, so "come back in an hour" can't park a thread for
     # an hour — and not jittered, since it's an instruction, not a guess.
     after = failure.retry_after if failure.is_a?(GraphWeaver::ServerError)
-    return [after, @max].min.to_f if after
+    return [after, @max_delay].min.to_f if after
 
-    seconds = [@backoff.call(@base, attempt), @max].min.to_f
+    seconds = [@backoff.call(@base_delay, attempt), @max_delay].min.to_f
     @jitter ? seconds * (0.5 + rand * 0.5) : seconds
   end
 end

data/lib/graph_weaver/rspec.rb

@@ -43,9 +43,8 @@ require_relative "testing"
 #     neither is there it says so rather than hunting for one.
 #   - :router plans against the composed supergraph: the dump, when that's
 #     what it is, else config.router = { supergraph: … }. Subgraphs are
-#     derived from what each loaded schema defines (Testing::Subgraphs);
-#     one nothing here serves is absent, and only a query that reaches its
-#     fields is refused.
+#     derived from what each loaded schema defines; one nothing here serves
+#     is absent, and only a query that reaches its fields is refused.
 #
 # What it wires up:
 #   - seed: defaults to rspec's --seed, so `rspec --seed 1234` reproduces
@@ -83,9 +82,12 @@ module GraphWeaver
         # so there is no idiom to discover and no way to leak a client forward
         rspec_config.before(:each) do
           @__graph_weaver_prior_client = GraphWeaver.client
-          @__graph_weaver_mode = GraphWeaver::Testing::RSpecIntegration.mode_for(
-            RSpec.current_example&.metadata || {},
-          )
+          metadata = RSpec.current_example&.metadata || {}
+          # what this example said, apart from what config.default_mode says
+          # for the ones that said nothing — a helper may only contradict the
+          # former
+          @__graph_weaver_tag = metadata[TAG] if metadata.key?(TAG)
+          @__graph_weaver_mode = GraphWeaver::Testing::RSpecIntegration.mode_for(metadata)
           if @__graph_weaver_mode
             GraphWeaver.client = GraphWeaver::Testing::RSpecIntegration.client_for(@__graph_weaver_mode)
           end
@@ -96,7 +98,10 @@ module GraphWeaver
 
           GraphWeaver.client = @__graph_weaver_prior_client
           remove_instance_variable(:@__graph_weaver_prior_client)
-          remove_instance_variable(:@__graph_weaver_mode)
+          # a refused tag raises before the mode is ever set, and its message
+          # is the one thing that says what to fix — a NameError out of the
+          # cleanup would report a second failure on top of it
+          remove_instance_variable(:@__graph_weaver_mode) if defined?(@__graph_weaver_mode)
         end
       end
 
@@ -125,9 +130,9 @@ module GraphWeaver
         when :router
           router = config.built_router
           router.context = config.context
-          # built once for the suite, so the trace has to be told where this
-          # example starts — otherwise have_fetched reads the last one's
-          router.reset_trace
+          # built once for the suite, so it has to be told where this example
+          # starts — the trace, and any faked subgraph's fabricated data
+          router.reset!
         end
       end
 
@@ -135,15 +140,19 @@ module GraphWeaver
       # whether or not this example took a client from the hook
       module Helpers
         # The fake this example runs against, built here rather than by the
-        # tag — which is how it takes options. `graphql: :fake` is exactly
-        # this call with none:
+        # tag — which is how it takes pins and options. `graphql: :fake` is
+        # exactly this call with none:
         #
         #      it "shows the two paid orders" do
-        #        graphql_fake(overrides: { "Reader.name" => "Ada",
-        #                                  "Reader.orders" => [{ "status" => "PAID" }, {}] })
+        #        graphql_fake("Reader.name" => "Ada",
+        #                     "Reader.orders" => [{ "status" => "PAID" }, {}])
         #        expect(DashboardQuery.execute!.reader.orders.size).to eq 2
         #      end
         #
+        # Pins lead, options follow: `graphql_fake("Money" => "12.00",
+        # values: :literal)`. Options are lowercase words, so a key with a
+        # dot or a leading capital is a pin wherever it is written.
+        #
         # Returns the client, for the assertions that are about the request:
         #
         #      fake = graphql_fake
@@ -152,10 +161,11 @@ module GraphWeaver
         #
         # Installed as GraphWeaver.client and restored after the example,
         # like a tagged one — so the tag is optional here, not required.
-        def graphql_fake(**options)
+        def graphql_fake(pins = {}, **options)
           claim_mode!(:fake)
+          refuse_seed!(options)
           options[:schema] ||= GraphWeaver::Testing.config.reference_schema!
-          GraphWeaver.client = GraphWeaver::Testing::FakeClient.new(**options)
+          GraphWeaver.client = GraphWeaver::Testing::FakeClient.new(pins, **options)
         end
 
         # Run this example against one schema class's real resolvers.
@@ -181,13 +191,37 @@ module GraphWeaver
           GraphWeaver.client = GraphWeaver::InProcess.new(schema, **options)
         end
 
+        # Run this example against the whole federated graph. `graphql:
+        # :router` is exactly this call with no argument; `fake:` is how the
+        # subgraphs it fakes fabricate — the pins and options graphql_fake
+        # takes, in one hash:
+        #
+        #      it "shows the carrier" do
+        #        graphql_router(fake: { "Shipment.carrier" => "UPS" })
+        #        …
+        #      end
+        #
+        # The router itself is built once for the suite — parsing a
+        # supergraph per example is real time — so this installs that one and
+        # tells it where this example starts.
+        def graphql_router(fake: nil)
+          claim_mode!(:router)
+          refuse_seed!(fake) if fake
+          router = GraphWeaver::Testing::RSpecIntegration.client_for(:router)
+          router.fake = fake if fake
+          GraphWeaver.client = router
+        end
+
         # A tag and a helper are two spellings of one choice, so they can
         # agree (`graphql: :fake` plus `graphql_fake(overrides:)` is the
         # documented way to pass options) but must not contradict: one of the
         # two is then a mistake, and silently letting the later one win hides
         # which.
-        def claim_mode!(mode)
-          tagged = defined?(@__graph_weaver_mode) ? @__graph_weaver_mode : nil
+        private def claim_mode!(mode)
+          # only an explicit tag can contradict a helper. config.default_mode
+          # is a fallback for examples that said nothing, so a helper is the
+          # example finally saying something — not a disagreement.
+          tagged = defined?(@__graph_weaver_tag) ? @__graph_weaver_tag : nil
           if tagged && tagged != mode
             # Kernel.raise: this module is mixed into every example group, so
             # it doesn't include Kernel for sorbet to find
@@ -199,6 +233,17 @@ module GraphWeaver
           @__graph_weaver_mode = mode
         end
 
+        # rspec's own --seed already drives the fake (config.seed takes it
+        # at suite start), so a per-example seed: is a second answer to one
+        # question — and the one that stops `rspec --seed` reproducing the run.
+        private def refuse_seed!(options)
+          return unless options.to_h.key?(:seed) || options.to_h.key?("seed")
+
+          Kernel.raise GraphWeaver::Error, "seed: isn't a per-example option — `rspec --seed 1234` " \
+            "reproduces the fabricated data along with the test order. For a suite that isn't " \
+            "rspec, set GraphWeaver::Testing.config.seed."
+        end
+
         # The GraphQL context this example's resolvers see — merged onto
         # config.context, and reset before the next example runs:
         #

data/lib/graph_weaver/schema_diff.rb

@@ -0,0 +1,293 @@
+# typed: true
+# frozen_string_literal: true
+
+require "graphql"
+
+module GraphWeaver
+  # What moved between two schemas — the dump you committed and the one the
+  # server serves now.
+  #
+  #      rake graph_weaver:schema:diff
+  #
+  # Compares the two *schemas*, not their SDL: graphql-ruby reorders and
+  # reformats what it prints, so a text diff reports churn no client can
+  # break on, and buries the one line that matters in a 3 MB file.
+  #
+  # Breaking is judged from the client's side — a query that validates
+  # against the dump and stops validating (or stops casting) against the
+  # server. That makes nullability directional: an *output* going non-null
+  # to nullable breaks a generated struct that expects a value, while an
+  # *input* going nullable to non-null breaks a query that omits it. The
+  # same signature change is breaking in one position and free in the other.
+  #
+  # This names what changed; it doesn't decide what to do about it.
+  # `queries:check` answers the narrower question — which of *your* queries
+  # a change actually reaches.
+  class SchemaDiff
+    # One difference. `coordinate` is the schema coordinate it happened at
+    # ("User", "User.email", "Query.search(first:)"), so a CI log stays
+    # greppable and a line can be pasted somewhere useful on its own.
+    Change = Data.define(:coordinate, :description, :breaking) do
+      def to_h = { "coordinate" => coordinate, "change" => description, "breaking" => breaking }
+
+      def to_s = "#{coordinate}  #{description}"
+    end
+
+    # Every schema carries these whether or not anything uses them, so a
+    # field newly typed Float would otherwise read as "type Float added".
+    BUILT_IN = GraphQL::Schema::BUILT_IN_TYPES.keys.to_set.freeze
+    private_constant :BUILT_IN
+
+    # every change found, breaking ones first, then by coordinate
+    attr_reader :changes
+
+    # before/after: two GraphQL::Schema classes — the dump and the server.
+    # source/target: what to call them in the headline (a path, a url).
+    def initialize(before, after, source: nil, target: nil)
+      @source = source
+      @target = target
+      @changes = []
+      compare(before, after)
+      @changes.sort_by! { |change| [change.breaking ? 0 : 1, change.coordinate] }
+    end
+
+    # the schemas agree — what CI gates on
+    def empty? = @changes.empty?
+
+    # the changes a query written against the dump can break on
+    def breaking = @changes.select(&:breaking)
+
+    # the rest: additions, deprecations, widenings a client absorbs
+    def compatible = @changes.reject(&:breaking)
+
+    # JSON-ready. One list, each entry saying whether it breaks — the
+    # counts are derivable, and two places to read "breaking" from is one
+    # too many.
+    def to_h = { "changes" => @changes.map(&:to_h) }
+
+    def report
+      return "#{subject}no changes" if empty?
+
+      [headline, *section("breaking:", breaking), *section("other:", compatible)].join("\n")
+    end
+    alias to_s report
+
+    def inspect = "#<#{self.class.name} #{@changes.size} changes, #{breaking.size} breaking>"
+
+    private
+
+    def subject
+      return "" unless @source
+
+      @target ? "#{@source} vs #{@target}: " : "#{@source}: "
+    end
+
+    def headline
+      count = "#{@changes.size} #{(@changes.size == 1) ? "change" : "changes"}"
+      "#{subject}#{count}, #{breaking.any? ? "#{breaking.size} breaking" : "none breaking"}"
+    end
+
+    def section(title, changes)
+      return [] if changes.empty?
+
+      width = changes.map { |change| change.coordinate.length }.max
+      ["", title, *changes.map { |change| "  #{change.coordinate.ljust(width)}  #{change.description}" }]
+    end
+
+    def change(coordinate, description, breaking: false)
+      @changes << Change.new(coordinate:, description:, breaking:)
+    end
+
+    def compare(before, after)
+      old_types = comparable_types(before)
+      new_types = comparable_types(after)
+
+      (old_types.keys - new_types.keys).each { |name| change(name, "removed", breaking: true) }
+      (new_types.keys - old_types.keys).each { |name| change(name, "added #{kind(new_types[name])}") }
+      (old_types.keys & new_types.keys).each { |name| compare_type(name, old_types[name], new_types[name]) }
+
+      note_unnamed_drift(before, after)
+    end
+
+    def comparable_types(schema)
+      schema.types.reject { |name, _| name.start_with?("__") || BUILT_IN.include?(name) }
+    end
+
+    def kind(type) = type.kind.name.downcase.tr("_", " ")
+
+    def compare_type(name, old, new)
+      # nothing below is comparable across kinds, and the kind change is
+      # the only thing worth saying about it
+      if old.kind.name != new.kind.name
+        return change(name, "#{kind(old)} -> #{kind(new)}", breaking: true)
+      end
+
+      case new.kind.name
+      when "OBJECT", "INTERFACE"
+        compare_fields(name, old, new)
+        compare_interfaces(name, old, new)
+      when "INPUT_OBJECT" then compare_input_fields(name, old, new)
+      when "ENUM" then compare_enum(name, old, new)
+      when "UNION" then compare_union(name, old, new)
+      end
+    end
+
+    def compare_fields(name, old, new)
+      before = old.fields
+      after = new.fields
+
+      (before.keys - after.keys).each { |field| change("#{name}.#{field}", "removed", breaking: true) }
+      (after.keys - before.keys).each do |field|
+        change("#{name}.#{field}", "added: #{signature(after[field])}")
+      end
+      (before.keys & after.keys).each do |field|
+        compare_field("#{name}.#{field}", before[field], after[field])
+      end
+    end
+
+    def compare_field(coordinate, old, new)
+      if signature(old) != signature(new)
+        change(coordinate, "#{signature(old)} -> #{signature(new)}",
+          breaking: breaks_output?(old.type, new.type))
+      end
+      compare_deprecation(coordinate, old, new)
+      compare_arguments(coordinate, old.arguments, new.arguments)
+    end
+
+    def compare_arguments(coordinate, before, after)
+      (before.keys - after.keys).each do |arg|
+        change("#{coordinate}(#{arg}:)", "argument removed", breaking: true)
+      end
+      (after.keys - before.keys).each do |arg|
+        change("#{coordinate}(#{arg}:)", "argument added: #{describe(after[arg])}",
+          breaking: required?(after[arg]))
+      end
+      (before.keys & after.keys).each do |arg|
+        compare_input(coordinate: "#{coordinate}(#{arg}:)", prefix: "argument ",
+          old: before[arg], new: after[arg])
+      end
+    end
+
+    # An input object's members are arguments, and break the same way — a
+    # removed one fails a query that sends it, a newly required one fails a
+    # query that doesn't.
+    def compare_input_fields(name, old, new)
+      before = old.arguments
+      after = new.arguments
+
+      (before.keys - after.keys).each { |field| change("#{name}.#{field}", "removed", breaking: true) }
+      (after.keys - before.keys).each do |field|
+        change("#{name}.#{field}", "added: #{describe(after[field])}", breaking: required?(after[field]))
+      end
+      (before.keys & after.keys).each do |field|
+        compare_input(coordinate: "#{name}.#{field}", prefix: "", old: before[field], new: after[field])
+      end
+    end
+
+    def compare_input(coordinate:, prefix:, old:, new:)
+      if signature(old) != signature(new)
+        # a default satisfies the new non-null, so the tightening reaches
+        # no query
+        breaking = breaks_input?(old.type, new.type) && !new.default_value?
+        change(coordinate, "#{prefix}#{signature(old)} -> #{signature(new)}", breaking:)
+      end
+      compare_deprecation(coordinate, old, new)
+    end
+
+    def compare_enum(name, old, new)
+      before = old.values
+      after = new.values
+
+      (before.keys - after.keys).each { |value| change("#{name}.#{value}", "enum value removed", breaking: true) }
+      (after.keys - before.keys).each { |value| change("#{name}.#{value}", "enum value added") }
+      (before.keys & after.keys).each { |value| compare_deprecation("#{name}.#{value}", before[value], after[value]) }
+    end
+
+    # A dropped member silently stops matching a `... on X` fragment, which
+    # is the quiet half of this: the query still validates.
+    def compare_union(name, old, new)
+      before = old.possible_types.map(&:graphql_name)
+      after = new.possible_types.map(&:graphql_name)
+
+      (before - after).each { |member| change("#{name}.#{member}", "union member removed", breaking: true) }
+      (after - before).each { |member| change("#{name}.#{member}", "union member added") }
+    end
+
+    def compare_interfaces(name, old, new)
+      return unless old.respond_to?(:interfaces) && new.respond_to?(:interfaces)
+
+      before = old.interfaces.map(&:graphql_name)
+      after = new.interfaces.map(&:graphql_name)
+
+      (before - after).each { |iface| change(name, "no longer implements #{iface}", breaking: true) }
+      (after - before).each { |iface| change(name, "now implements #{iface}") }
+    end
+
+    def compare_deprecation(coordinate, old, new)
+      return unless old.respond_to?(:deprecation_reason)
+
+      was = old.deprecation_reason
+      now = new.deprecation_reason
+      return if was == now
+
+      change(coordinate, now ? "deprecated: #{now}" : "no longer deprecated")
+    end
+
+    # The walk names what a client breaks on. A description, a directive
+    # definition, an argument default moves the SDL without appearing
+    # above — still drift, and a gate that went green on it would be worse
+    # than one that admits it can't name it.
+    def note_unnamed_drift(before, after)
+      return unless @changes.empty?
+      return if before.to_definition == after.to_definition
+
+      change("(schema)", "changed in ways this summary doesn't name — compare the dumps")
+    end
+
+    def signature(member) = member.type.to_type_signature
+
+    def describe(argument)
+      "#{signature(argument)}#{" — required" if required?(argument)}"
+    end
+
+    def required?(argument) = argument.type.non_null? && !argument.default_value?
+
+    # A signature split into its shape and where the `!`s sit: "[User!]!"
+    # => ["[User]", [.., true(r), true(])]]. Comparing the two separately
+    # is what lets nullability be read directionally.
+    def shape(signature)
+      bare = +""
+      nullability = []
+      signature.each_char do |char|
+        if char == "!"
+          nullability[-1] = true
+        else
+          bare << char
+          nullability << false
+        end
+      end
+      [bare, nullability]
+    end
+
+    # An output the client can no longer trust: a different type or list
+    # depth, or a guarantee withdrawn — `String!` to `String` hands a
+    # generated struct the nil it declared it wouldn't get.
+    def breaks_output?(old, new)
+      was, was_null = shape(old.to_type_signature)
+      now, now_null = shape(new.to_type_signature)
+      return true if was != now
+
+      was_null.each_index.any? { |i| was_null[i] && !now_null[i] }
+    end
+
+    # An input the client can no longer satisfy: a different type, or a
+    # guarantee demanded that wasn't demanded before.
+    def breaks_input?(old, new)
+      was, was_null = shape(old.to_type_signature)
+      now, now_null = shape(new.to_type_signature)
+      return true if was != now
+
+      now_null.each_index.any? { |i| now_null[i] && !was_null[i] }
+    end
+  end
+end