eco-helpers 3.2.14 → 3.2.23

data/lib/eco/api/usecases/graphql/samples/pages/template/deploy/loop.rb

@@ -0,0 +1,155 @@
+module Eco::API::UseCases::GraphQL::Samples::Pages::Template
+  module Deploy
+    # Deploy → verify → monitor orchestration (Phase 5).
+    #
+    # Ties the four offline-safe pieces into one pass:
+    #   1. APPLY   — hand a gem `Diff::Deploy` plan to the `Applier` (dry-run by DEFAULT; live only
+    #                behind an explicit `commit: true` + executor).
+    #   2. DRIFT   — re-read the target and run a pre/post self-version diff, then compare the applied
+    #                delta to the intended delta (`DriftReport`). Reports drift honestly.
+    #   3. VERIFY  — run the post-deploy template doc through a `Verifier` (ecoportal-qa when present,
+    #                else the null verifier).
+    #   4. MONITOR — optional sync-readiness scan of a register subset against the post-deploy template.
+    #
+    # Everything is OFFLINE against fixtures. The two seams that would touch a live API — applying the
+    # batch and re-reading the target — are injected as callables, so specs (and dry-runs) drive them
+    # with fixtures and a `RecordingExecutor`:
+    #
+    #   loop = Deploy::Loop.new(
+    #     plan:       gem_deploy_plan,
+    #     intended:   source_version_diff,        # the diff the plan was built from
+    #     pre_doc:    target_before_doc,          # the target template BEFORE apply
+    #     reread:     -> { recording_executor.doc } # how to fetch the target AFTER apply (post-deploy doc)
+    #   )
+    #   result = loop.run(commit: false, executor: recording_executor, entries: register_entries)
+    #
+    #   result.applied            # => Applier::Outcome
+    #   result.drift              # => DriftReport (nil if pre_doc/reread not supplied)
+    #   result.verdict            # => Verifier::Verdict
+    #   result.sync_readiness     # => SyncReadiness (nil if no entries)
+    #   result.ok?                # => apply not blocked && drift match && verify pass
+    #   result.report             # => aggregate human summary
+    class Loop
+      # Aggregate outcome of one deploy→verify→monitor pass.
+      Result = Struct.new(:applied, :drift, :verdict, :sync_readiness, keyword_init: true) do
+        # Overall gate: the apply was not blocked, the drift (if checked) matched, and verify passed.
+        def ok?
+          applied_ok? && drift_ok? && verify_ok?
+        end
+
+        def applied_ok?
+          applied && applied.skipped_reason.nil?
+        end
+
+        def drift_ok?
+          drift.nil? || drift.match?
+        end
+
+        def verify_ok?
+          verdict.nil? || verdict.pass?
+        end
+
+        def to_h
+          {
+            ok:             ok?,
+            applied:        applied&.to_h,
+            drift:          drift&.to_h,
+            verdict:        verdict&.to_h,
+            sync_readiness: sync_readiness&.to_h
+          }.compact
+        end
+
+        def report
+          [
+            "DEPLOY LOOP: #{ok? ? 'OK' : 'ATTENTION NEEDED'}",
+            applied_line,
+            drift&.report,
+            verdict&.report,
+            sync_readiness&.report
+          ].compact.join("\n\n")
+        end
+
+        private
+
+        def applied_line
+          if applied.skipped_reason
+            "APPLY: BLOCKED — #{applied.skipped_reason}"
+          elsif applied.committed?
+            "APPLY: committed #{applied.commands.size} command(s)"
+          else
+            "APPLY: dry-run — #{applied.commands.size} command(s) would be sent"
+          end
+        end
+      end
+
+      # @param plan     [Ecoportal::API::GraphQL::Diff::Deploy] the gem deploy plan.
+      # @param intended [#changes, nil] the source diff the plan was built from (for drift check).
+      # @param pre_doc  [Hash, nil] the target template doc BEFORE apply (for drift check).
+      # @param reread   [#call, nil] returns the target template doc AFTER apply (for drift + verify).
+      # @param target   [#id, nil] the target model, forwarded to the Applier for a live apply.
+      # @param verifier [Verifier, nil] injected verifier; defaults to Verifier.default.
+      # @param diff_builder [#call, nil] `diff_builder.call(pre_doc, post_doc)` returns the applied
+      #   self-version diff (must expose `#changes`). Defaults to the gem's `Diff::VersionDiff` — which
+      #   lives in the (currently unreleased) gem Diff module, so it is resolved LAZILY at drift time,
+      #   never at load. Injectable so offline callers/specs can supply their own diff builder.
+      def initialize(plan:, intended: nil, pre_doc: nil, reread: nil, target: nil, verifier: nil,
+                     diff_builder: nil)
+        @plan         = plan
+        @intended     = intended
+        @pre_doc      = pre_doc
+        @reread       = reread
+        @target       = target
+        @verifier     = verifier || Verifier.default
+        @diff_builder = diff_builder
+      end
+
+      # Run the full pass.
+      #
+      # @param commit   [Boolean] false = dry-run (default). true = live apply.
+      # @param executor [#execute_workflow_commands, nil] the mutation facade (live) or a
+      #   RecordingExecutor (offline). Required for both commit AND for an offline drift check
+      #   (the RecordingExecutor replays the batch to produce the post-deploy doc).
+      # @param allow_partial [Boolean] forwarded to the Applier / gem plan.
+      # @param entries [Array, nil] register subset for the sync-readiness monitor (optional).
+      # @return [Result]
+      def run(commit: false, executor: nil, allow_partial: false, entries: nil)
+        applied = Applier.new(@plan, target: @target).apply(
+          commit: commit, executor: executor, allow_partial: allow_partial
+        )
+
+        post_doc = applied.skipped_reason.nil? ? reread_post_doc : nil
+        drift    = build_drift(post_doc)
+        verdict  = post_doc ? @verifier.verify(post_doc) : nil
+        monitor  = build_monitor(post_doc, entries)
+
+        Result.new(applied: applied, drift: drift, verdict: verdict, sync_readiness: monitor)
+      end
+
+      private
+
+      def reread_post_doc
+        @reread&.call
+      end
+
+      def build_drift(post_doc)
+        return nil unless @intended && @pre_doc && post_doc
+
+        DriftReport.new(intended: @intended, applied: diff_builder.call(@pre_doc, post_doc))
+      end
+
+      # The gem's Diff::VersionDiff is the default applied-diff builder. Resolved lazily so this file
+      # never forces the (unreleased) gem Diff module at load time.
+      def diff_builder
+        @diff_builder ||= lambda do |pre, post|
+          Ecoportal::API::GraphQL::Diff::VersionDiff.new(pre, post)
+        end
+      end
+
+      def build_monitor(post_doc, entries)
+        return nil if entries.nil? || Array(entries).empty?
+
+        SyncReadiness.new(template_doc: post_doc || @pre_doc, entries: entries)
+      end
+    end
+  end
+end

data/lib/eco/api/usecases/graphql/samples/pages/template/deploy/recording_executor.rb

@@ -0,0 +1,58 @@
+module Eco::API::UseCases::GraphQL::Samples::Pages::Template
+  module Deploy
+    # Offline stand-in for a live workflow-command executor.
+    #
+    # Records every batch it is handed and (optionally) applies each command to an in-memory template
+    # doc via a caller-supplied `mutator`, so a deploy loop can compute a faithful POST-deploy snapshot
+    # WITHOUT any API call. This is what makes the pre/post self-version drift check runnable offline:
+    # the applied delta is derived from replaying the batch onto the pre-deploy doc.
+    #
+    # It satisfies BOTH executor contracts the gem may call:
+    #   * `execute_workflow_commands(commands)`            (gem Diff::Deploy#execute! positional)
+    #   * `execute_workflow_commands(model, commands:)`    (gem Builder::Page facade)
+    #
+    #   rec = RecordingExecutor.new(doc: before_doc.dup, mutator: my_replayer)
+    #   plan.execute!(rec)
+    #   rec.batches         # => [[cmd, cmd, ...]]
+    #   rec.doc             # => the mutated post-deploy doc (if a mutator was given)
+    class RecordingExecutor
+      attr_reader :batches, :doc
+
+      # @param doc     [Hash, nil] a template/page doc to mutate as commands are replayed.
+      # @param mutator [#call, nil] `mutator.call(doc, command)` applies one command to `doc`
+      #   in place (or returns the new doc). When nil, the doc is left untouched (record-only).
+      def initialize(doc: nil, mutator: nil)
+        @doc     = doc
+        @mutator = mutator
+        @batches = []
+      end
+
+      def execute_workflow_commands(model_or_commands, commands: nil)
+        batch = commands || model_or_commands
+        @batches << batch
+        replay(batch) if @mutator
+        record_response(batch)
+      end
+
+      # Marker so the applier does not double-wrap this executor.
+      def arity_ok_for_positional_commands?
+        true
+      end
+
+      # Every command across all recorded batches, flattened, in order.
+      def all_commands
+        @batches.flatten(1)
+      end
+
+      private
+
+      def replay(batch)
+        Array(batch).each { |command| @doc = @mutator.call(@doc, command) || @doc }
+      end
+
+      def record_response(batch)
+        { recorded: batch.size }
+      end
+    end
+  end
+end

data/lib/eco/api/usecases/graphql/samples/pages/template/deploy/sync_readiness.rb

@@ -0,0 +1,178 @@
+module Eco::API::UseCases::GraphQL::Samples::Pages::Template
+  module Deploy
+    # Sync-readiness monitoring.
+    #
+    # Given a register subset (its entries) and the register's ACTIVE template, report which entries
+    # CAN sync vs which cannot — where "can sync" means: every field the template marks REQUIRED is
+    # present on the entry with a non-empty value AND typed correctly (the entry field's type matches
+    # the template field's type). This is the pre-flight an integration runs before pushing entries
+    # downstream, and the drift-detection the customer-facing integrations mandate needs.
+    #
+    # Operates on raw docs (template doc + entry docs) so it is session-less and offline-runnable:
+    #   * template doc: the JSON the gem returns for a template (stages/sections/dataFields).
+    #   * entry docs:   each register entry as { 'id' =>, 'fields' => [ {id/label/type/value}, ... ] }
+    #     (or anything exposing the same shape). A field is matched to a template field by id first,
+    #     then by label — mirroring how the pairing engine falls back.
+    #
+    #   monitor = SyncReadiness.new(template_doc: tpl, entries: [e1, e2, ...])
+    #   monitor.ready         # => [EntryReadiness(ready: true), ...]
+    #   monitor.not_ready     # => [EntryReadiness(ready: false, ...), ...]
+    #   monitor.summary       # => { total:, ready:, not_ready: }
+    #   monitor.report        # => human summary
+    class SyncReadiness
+      # Per-entry readiness verdict.
+      EntryReadiness = Struct.new(:entry_id, :ready, :missing_required, :type_mismatches,
+                                  keyword_init: true) do
+        def ready?
+          ready ? true : false
+        end
+
+        def reasons
+          out = Array(missing_required).map { |m| "missing required '#{m}'" }
+          Array(type_mismatches).each do |m|
+            out << "type mismatch '#{m[:label]}' (want #{m[:expected]}, got #{m[:actual]})"
+          end
+          out
+        end
+
+        def to_h
+          { entry_id: entry_id, ready: ready?, missing_required: Array(missing_required),
+            type_mismatches: Array(type_mismatches) }
+        end
+      end
+
+      attr_reader :entries
+
+      # @param template_doc [Hash] the active template doc.
+      # @param entries [Array<Hash,#id>] register entry docs to assess.
+      def initialize(template_doc:, entries:)
+        @template_doc = template_doc || {}
+        @entries      = Array(entries)
+      end
+
+      def verdicts
+        @verdicts ||= @entries.map { |entry| assess(entry) }
+      end
+
+      def ready
+        verdicts.select(&:ready?)
+      end
+
+      def not_ready
+        verdicts.reject(&:ready?)
+      end
+
+      def summary
+        { total: verdicts.size, ready: ready.size, not_ready: not_ready.size }
+      end
+
+      def to_h
+        { summary: summary, entries: verdicts.map(&:to_h) }
+      end
+
+      def report
+        lines = ["SYNC READINESS: #{summary[:ready]}/#{summary[:total]} entries ready"]
+        not_ready.each do |v|
+          lines << "  * entry #{v.entry_id}: NOT READY"
+          v.reasons.each { |r| lines << "      - #{r}" }
+        end
+        lines.join("\n")
+      end
+
+      private
+
+      # The template fields, indexed by id and by (downcased) label, carrying type + required.
+      def template_fields
+        @template_fields ||= begin
+          out = { by_id: {}, by_label: {} }
+          each_template_field do |f|
+            spec = { id: f['id'], label: f['label'], type: field_type(f), required: !!f['required'] }
+            out[:by_id][f['id']] = spec if f['id']
+            out[:by_label][label_key(f['label'])] = spec if f['label']
+          end
+          out
+        end
+      end
+
+      def required_fields
+        @required_fields ||= template_fields[:by_id].values.select { |s| s[:required] }.
+          +(template_fields[:by_label].values.select { |s| s[:required] }).
+          uniq { |s| s[:id] || s[:label] }
+      end
+
+      def assess(entry)
+        entry_fields = index_entry_fields(entry)
+        missing      = []
+        mismatches   = []
+
+        required_fields.each do |spec|
+          efield = entry_fields[:by_id][spec[:id]] || entry_fields[:by_label][label_key(spec[:label])]
+          if efield.nil? || value_empty?(efield[:value])
+            missing << spec[:label]
+          elsif spec[:type] && efield[:type] && spec[:type] != efield[:type]
+            mismatches << { label: spec[:label], expected: spec[:type], actual: efield[:type] }
+          end
+        end
+
+        EntryReadiness.new(
+          entry_id:         entry_id(entry),
+          ready:            missing.empty? && mismatches.empty?,
+          missing_required: missing,
+          type_mismatches:  mismatches
+        )
+      end
+
+      def index_entry_fields(entry)
+        out = { by_id: {}, by_label: {} }
+        entry_field_docs(entry).each do |f|
+          spec = { id: f['id'] || f[:id], label: f['label'] || f[:label],
+                   type: field_type(f), value: f['value'] || f[:value] }
+          out[:by_id][spec[:id]]                    = spec if spec[:id]
+          out[:by_label][label_key(spec[:label])]   = spec if spec[:label]
+        end
+        out
+      end
+
+      def entry_field_docs(entry)
+        return Array(entry['fields'] || entry[:fields]) if entry.is_a?(Hash)
+        return entry.components.to_a if entry.respond_to?(:components)
+
+        []
+      end
+
+      def entry_id(entry)
+        return entry['id'] || entry[:id] if entry.is_a?(Hash)
+
+        entry.respond_to?(:id) ? entry.id : nil
+      end
+
+      def each_template_field(&block)
+        Array(@template_doc['stages']).each do |st|
+          Array(st['sections']).each do |sec|
+            fields_of(sec).each(&block)
+          end
+        end
+      end
+
+      def fields_of(section)
+        Array(section['dataFields']) + Array(section['leftDataFields']) + Array(section['rightDataFields'])
+      end
+
+      def field_type(field)
+        field['__typename'] || field['type'] || field[:type]
+      end
+
+      def label_key(label)
+        label.to_s.strip.downcase
+      end
+
+      def value_empty?(value)
+        return true if value.nil?
+        return value.strip.empty? if value.is_a?(String)
+        return value.empty? if value.respond_to?(:empty?)
+
+        false
+      end
+    end
+  end
+end

data/lib/eco/api/usecases/graphql/samples/pages/template/deploy/verifier.rb

@@ -0,0 +1,141 @@
+module Eco::API::UseCases::GraphQL::Samples::Pages::Template
+  module Deploy
+    # Pluggable post-deploy verification interface.
+    #
+    # The deploy loop wants to run the freshly-deployed template through a check framework (ideally the
+    # `ecoportal-qa` gem's check runner). But `ecoportal-qa` is NOT a hard dependency of eco-helpers,
+    # so we do not `require` it here. Instead the loop calls a small `Verifier` interface; a concrete
+    # verifier is injected. When `ecoportal-qa` IS on the load path, `QaVerifier` wires it in; when it
+    # isn't, `NullVerifier` (always-pass, records that qa was unavailable) keeps the loop runnable
+    # offline.
+    #
+    # A verifier receives the post-deploy template doc and returns a `Verdict`.
+    #
+    #   verdict = Verifier.default.verify(post_deploy_doc)
+    #   verdict.pass?      # => true/false
+    #   verdict.findings   # => [ {severity:, message:}, ... ]
+    class Verifier
+      # A verification verdict. `pass?` is the gate; `findings` carries per-check detail.
+      Verdict = Struct.new(:pass, :findings, :verifier, keyword_init: true) do
+        def pass?
+          pass ? true : false
+        end
+
+        def failures
+          Array(findings).select { |f| %i[error fail].include?((f[:severity] || f['severity'])&.to_sym) }
+        end
+
+        def to_h
+          { pass: pass?, verifier: verifier, findings: Array(findings) }
+        end
+
+        def report
+          head = "VERIFY (#{verifier}): #{pass? ? 'PASS' : 'FAIL'}"
+          return head if Array(findings).empty?
+
+          ([head] + Array(findings).map do |f|
+            "  - [#{f[:severity] || f['severity']}] #{f[:message] || f['message']}"
+          end).join("\n")
+        end
+      end
+
+      # The verifier the loop uses when none is injected: qa if available, else the null verifier.
+      def self.default
+        qa_available? ? QaVerifier.new : NullVerifier.new
+      end
+
+      # Is the ecoportal-qa check framework loadable?
+      def self.qa_available?
+        return @qa_available unless @qa_available.nil?
+
+        @qa_available = begin
+          require 'ecoportal/qa'
+          defined?(::Ecoportal::QA) ? true : false
+        rescue LoadError
+          false
+        end
+      end
+
+      # Reset the memoised availability probe (used by specs that stub the load path).
+      def self.reset_qa_probe!
+        @qa_available = nil
+      end
+
+      # Subclass / duck-type contract: return a Verdict for the given template doc.
+      def verify(_template_doc)
+        raise NotImplementedError, "#{self.class} must implement #verify(template_doc)"
+      end
+
+      # Always-pass verifier used when no real check framework is wired in. It is honest about it:
+      # the verdict records that qa was unavailable so a report never falsely claims "qa verified".
+      class NullVerifier < Verifier
+        def verify(_template_doc)
+          Verdict.new(
+            pass:     true,
+            verifier: 'null',
+            findings: [{ severity: :info, message: 'ecoportal-qa not available; no checks run' }]
+          )
+        end
+      end
+
+      # Adapter onto the ecoportal-qa check runner. Kept dependency-free at load time — it only touches
+      # `Ecoportal::QA` inside #verify, so requiring this file never forces the qa gem. The exact qa
+      # runner API is intentionally accessed through a single seam (`run_qa`) so it is easy to correct
+      # once the qa public surface stabilises (see TODO).
+      #
+      # TODO(qa-integration): the qa check-runner public API is still moving (see the qa repo's
+      # PHASE3-SCOPE.md). This adapter assumes a `check_set.run(doc)`-style entry returning objects
+      # responding to `#pass?` and `#findings`. Confirm and adjust `run_qa` when qa is pinned as a dep.
+      class QaVerifier < Verifier
+        def initialize(check_set: nil)
+          super()
+          @check_set = check_set
+        end
+
+        def verify(template_doc)
+          result = run_qa(template_doc)
+          Verdict.new(pass: result_pass?(result), verifier: 'ecoportal-qa', findings: result_findings(result))
+        rescue StandardError => e
+          Verdict.new(pass: false, verifier: 'ecoportal-qa',
+                      findings: [{ severity: :error, message: "qa verification raised: #{e.message}" }])
+        end
+
+        private
+
+        # SINGLE integration seam — the one place that knows the qa runner shape.
+        def run_qa(template_doc)
+          set = @check_set || default_check_set
+          set.run(template_doc)
+        end
+
+        def default_check_set
+          raise NotImplementedError, 'no qa check_set injected and no default wired' unless defined?(::Ecoportal::QA)
+
+          # Placeholder: the concrete constructor is confirmed once qa is a pinned dependency.
+          if ::Ecoportal::QA.respond_to?(:default_check_set)
+            ::Ecoportal::QA.default_check_set
+          else
+            (raise NotImplementedError,
+                   'qa default check set not available')
+          end
+        end
+
+        def result_pass?(result)
+          return result.pass? if result.respond_to?(:pass?)
+
+          Array(result).all? { |r| r.respond_to?(:pass?) ? r.pass? : true }
+        end
+
+        def result_findings(result)
+          source = result.respond_to?(:findings) ? result.findings : result
+          Array(source).map do |f|
+            next f if f.is_a?(Hash)
+
+            { severity: (f.respond_to?(:severity) ? f.severity : :info),
+              message:  (f.respond_to?(:message) ? f.message : f.to_s) }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/eco/api/usecases/graphql/samples/pages/template/deploy.rb

@@ -0,0 +1,21 @@
+module Eco::API::UseCases::GraphQL::Samples::Pages::Template
+  # Phase 5: deploy → verify → monitor loop for template (workflow) changes.
+  #
+  # Consumes a gem `Ecoportal::API::GraphQL::Diff::Deploy` command batch (from
+  # `Diff::Deploy.from_versions(...)`), dry-run applies it (live behind an explicit `commit:` flag),
+  # confirms the applied delta matches the intended delta via a pre/post self-version diff
+  # (`Diff::VersionDiff`), verifies the result through a pluggable `Verifier` (ecoportal-qa when
+  # present), and reports register sync-readiness against the deployed template.
+  #
+  # All components are session-less and offline-runnable against fixtures — the live seams (apply /
+  # re-read) are injected. See each file's header. Dry-run is the DEFAULT.
+  module Deploy
+  end
+end
+
+require_relative 'deploy/applier'
+require_relative 'deploy/recording_executor'
+require_relative 'deploy/drift_report'
+require_relative 'deploy/verifier'
+require_relative 'deploy/sync_readiness'
+require_relative 'deploy/loop'

data/lib/eco/api/usecases/graphql/samples/pages/template.rb

@@ -0,0 +1,11 @@
+module Eco::API::UseCases::GraphQL::Samples::Pages
+  # Template (workflow) build-from-scratch + (later) diff-and-update samples.
+  # See the ecoportal-api-graphql repo's internal docs.
+  module Template
+  end
+end
+
+require_relative 'template/command_emitter'
+require_relative 'template/base'
+require_relative 'template/csv_build'
+require_relative 'template/deploy'

data/lib/eco/api/usecases/graphql/samples/pages.rb

@@ -0,0 +1,9 @@
+module Eco::API::UseCases::GraphQL::Samples
+  module Pages
+  end
+end
+
+require_relative 'pages/page'
+require_relative 'pages/register'
+require_relative 'pages/org_page'
+require_relative 'pages/template'

data/lib/eco/api/usecases/graphql/samples.rb

@@ -5,3 +5,4 @@ end
 
 require_relative 'samples/location'
 require_relative 'samples/contractors'
+require_relative 'samples/pages'

data/lib/eco/api/usecases/graphql.rb

@@ -10,4 +10,5 @@ end
 require_relative 'graphql/helpers'
 require_relative 'graphql/utils'
 require_relative 'graphql/base'
+require_relative 'graphql/compat'
 require_relative 'graphql/samples'

data/lib/eco/api/usecases/ooze_samples/ooze_base_case.rb

@@ -224,6 +224,10 @@ class Eco::API::UseCases::OozeSamples::OozeBaseCase < Eco::API::Common::Loaders:
     return if options.dig(:feedback, :only_stats)
     return unless (patch = (patch_doc(entry) || {})['page'])
 
+    # Affirmative dry-run line so an empty/blank page no longer reads as a silent no-op.
+    # A create body carries :templateId (CreateFromTemplateInput); anything else is an update.
+    verb = patch.is_a?(Hash) && patch[:templateId] ? 'create' : 'update'
+    log(:info) { "[dry-run] would #{verb} #{object_reference(entry)} with:" }
     pp patch
   end
 

data/lib/eco/api/usecases/ooze_samples/register_update_case.rb

@@ -54,7 +54,10 @@ class Eco::API::UseCases::OozeSamples::RegisterUpdateCase < Eco::API::UseCases::
     return unless (pending = queue_shift(ooze_id))
 
     update_ooze(pending).tap do |result|
-      if result.is_a?(Ecoportal::API::Common::Response)
+      # Duck-type, not is_a?: the GraphQL Compat::Response responds to success?/status but is
+      # NOT an Ecoportal::API::Common::Response, so is_a? silently skipped every GraphQL update
+      # (updated/failed stuck at 0). false/nil returns (dry-run / no-op) still fall through.
+      if result.respond_to?(:success?)
         if result.success?
           @updated_oozes += 1
         else
@@ -105,7 +108,13 @@ class Eco::API::UseCases::OozeSamples::RegisterUpdateCase < Eco::API::UseCases::
   def enqueue(object)
     return unless object.respond_to?(:id)
 
-    unless object.is_a?(Ecoportal::API::V2::Page) or object.is_a?(Ecoportal::API::V2::Pages::PageStage)
+    # Accept v2 Page/PageStage, or any duck-typed entry that carries change-tracking
+    # (the GraphQL compat page responds to #dirty? and #as_update). The strict v2-class
+    # guard otherwise raised for GraphQL pages under OozeRedirect.
+    queueable = object.is_a?(Ecoportal::API::V2::Page) ||
+                object.is_a?(Ecoportal::API::V2::Pages::PageStage) ||
+                (object.respond_to?(:dirty?) && object.respond_to?(:as_update))
+    unless queueable
       msg = "Queuing is just for entries. Expecting Page or PageStage. Given: #{object.class}"
       raise ArgumentError, msg
     end
@@ -182,7 +191,8 @@ class Eco::API::UseCases::OozeSamples::RegisterUpdateCase < Eco::API::UseCases::
   def update_oozes(batched_oozes = batch_queue)
     batched_oozes.each do |ooze|
       update_ooze(ooze).tap do |result|
-        if result.is_a?(Ecoportal::API::Common::Response)
+        # Duck-type, not is_a? — see #before_loading_new_target (GraphQL Compat::Response).
+        if result.respond_to?(:success?)
           if result.success?
             @updated_oozes += 1
           else

data/lib/eco/version.rb

@@ -1,3 +1,3 @@
 module Eco
-  VERSION = '3.2.14'.freeze
+  VERSION = '3.2.23'.freeze
 end