ecoportal-api-graphql 1.3.16 → 2.0.0

data/lib/ecoportal/api/graphql/base/preset_view.rb

@@ -1,15 +1,150 @@
-module Ecoportal
+module Ecoportal
   module API
     class GraphQL
       module Base
         # A register preset view — saved column/sort/filter configuration for previewPages.
         # Scripts use the id as `presetViewId` in register.previewPages queries.
         class PresetView < Logic::BaseModel
+          # `fieldConfigurations` is a passarray (leaf) invisible to the default
+          # DiffService; LeafDiffService detects it as a full-set replace, which is what
+          # makes a columns-only change reach `#as_input` at all (before it, the array was
+          # dropped from the flat diff and no mutation was issued). The read-key/shape
+          # conversion that change then needs is handled below — the GAP-P1 that comment
+          # referred to as a separate pending converter is closed by it.
+          # See Diffable::LeafDiffService.
+          DIFF_CLASS = Ecoportal::API::Common::GraphQL::Model::Diffable::LeafDiffService
+
+          # READ key vs WRITE key — and, on update, read SHAPE vs write SHAPE.
+          #
+          # The API RETURNS the collection as `fieldConfigurations`, a plain list (see the
+          # `passarray` below — that stays as-is, consumers read it). The mutations call it
+          # `fieldConfigs`, and the two mutations do NOT agree on its shape. Schema-verified
+          # against the live introspection dump (20260730):
+          #
+          #   CreatePresetViewInput.fieldConfigs : [FieldConfigurationInput!]!
+          #   UpdatePresetViewInput.fieldConfigs : FieldConfigurationOneToManyInput!
+          #                                        { additions:, deletions:, updates: }
+          #
+          # Both are NON_NULL with no default value — i.e. REQUIRED on every call — while the
+          # `FieldConfigurationOneToManyInput` members each default to `[]`, so `{}` is a
+          # valid no-op value for an update that does not touch the columns.
+          #
+          # Emitting the read key `fieldConfigurations` is an unknown-argument error, and
+          # emitting the read LIST under `fieldConfigs` is a type error: either one rejects
+          # the WHOLE mutation, a `name`-only edit included.
+          #
+          # `#as_input` emits the UPDATE shape. `Logic::Mutation#as_input` hands a read model
+          # straight to `model.as_input` without telling it which mutation it feeds, and the
+          # only model-driven path is `register.preset_view.update`: a read model carries an
+          # `id`, which `CreatePresetViewInput` does not even accept. Create is built from a
+          # caller-supplied Hash (see Builder::Register::PresetView) whose `fieldConfigs` is
+          # already the plain array the schema wants — it needs no conversion.
+          READ_KEY = 'fieldConfigurations'.freeze
+
+          # The fields `FieldConfigurationInput` accepts (same dump). The read nodes also
+          # carry `__typename` — the read side is a union, see Fragment::FieldConfiguration —
+          # which the input type does NOT accept, so nodes are whitelisted through this list
+          # rather than passed along verbatim.
+          FIELD_CONFIG_INPUT_KEYS = %i[
+            id key name weight dataFieldLabel type showTime valueToShow mode displayUid
+          ].freeze
+
           passkey :id
           passthrough :name, :registerId
           passboolean :global
           passarray   :fieldConfigurations
           passthrough :sorter # { key:, direction:, missing: }
+
+          class << self
+            # Turns a raw mutation-input diff into a valid `UpdatePresetViewInput`: drops the
+            # read key and sets `fieldConfigs` to the one-to-many delta.
+            #
+            # Idempotent — the read key is deleted and the delta is recomputed from
+            # `doc`/`original_doc`, so a second application yields the same Hash. That is what
+            # makes it safe for both seams (`#as_input` and `Input::PresetView::Update
+            # .from_model`) to call it on the same Hash.
+            #
+            # @param model [PresetView] the subject (read) model.
+            # @param input [Hash, nil] the mutation input hash so far (nil when nothing in the
+            #   flat diff changed).
+            # @return [Hash, nil] +input+ with a schema-valid `fieldConfigs`, or nil when
+            #   neither the flat diff nor the columns changed (no mutation to send).
+            def build_update_input(model, input)
+              return input unless model.respond_to?(:field_configs_delta)
+
+              delta = model.field_configs_delta
+              return input if input.nil? && delta.empty?
+
+              input ||= {}
+              input.delete(:fieldConfigurations)
+              input.delete(READ_KEY)
+              input[:id]         ||= model.id if model.respond_to?(:id)
+              input[:fieldConfigs] = delta
+              input
+            end
+
+            # @param node [Hash] one `fieldConfigurations` read node.
+            # @return [Hash] the node reduced to the keys `FieldConfigurationInput` accepts,
+            #   symbol-keyed. Keys the read selection did not ask for are simply absent.
+            def field_config_input(node)
+              FIELD_CONFIG_INPUT_KEYS.each_with_object({}) do |key, out|
+                str      = key.to_s
+                out[key] = node[str] if node.key?(str)
+                out[key] = node[key] if node.key?(key)
+              end
+            end
+          end
+
+          # The `FieldConfigurationOneToManyInput` delta between the server baseline
+          # (`original_doc`) and the current `doc`, matched on the config `id`:
+          # `additions` = nodes with no known id, `deletions` = baseline ids that are gone,
+          # `updates` = known nodes whose (input-visible) content changed. Empty members are
+          # omitted, so an untouched collection yields `{}` — the valid no-op.
+          #
+          # Computed DIRECTLY from the docs rather than from the flat diff, for the same
+          # reason as {Logic::Input::IdDiffFields}: `passarray` leaves are dropped by the
+          # cascaded DiffService.
+          #
+          # @return [Hash] `{ additions:, deletions:, updates: }`, empty members omitted.
+          def field_configs_delta
+            current  = field_config_nodes(doc)
+            original = field_config_nodes(original_doc)
+            known    = original.filter_map {|node| node[:id]}
+
+            additions = current.reject {|node| node[:id] && known.include?(node[:id])}
+            updates   = (current - additions) - original
+            deletions = known - current.filter_map {|node| node[:id]}
+
+            {}.tap do |delta|
+              delta[:additions] = additions unless additions.empty?
+              delta[:deletions] = deletions unless deletions.empty?
+              delta[:updates]   = updates   unless updates.empty?
+            end
+          end
+
+          # Mutation input for this preset view, shaped for `updatePresetView`.
+          # @see .build_update_input
+          def as_input(target_class: nil, clientMutationId: '')
+            input = self.class.build_update_input(self, super)
+            return input if input.nil? || target_class
+
+            # `super` merges it only when it built the Hash itself; a columns-only change
+            # synthesises the Hash here, so keep the wire payload identical either way.
+            input[:clientMutationId] = clientMutationId.to_s unless input.key?(:clientMutationId)
+            input
+          end
+
+          private
+
+          # @param source_doc [Hash, nil] `doc` or `original_doc`.
+          # @return [Array<Hash>] the read nodes, each reduced to input-accepted keys.
+          def field_config_nodes(source_doc)
+            return [] if source_doc.nil?
+
+            Array(source_doc[READ_KEY]).
+              grep(Hash).
+              map {|node| self.class.field_config_input(node)}
+          end
         end
       end
     end

data/lib/ecoportal/api/graphql/base/register.rb

@@ -3,6 +3,11 @@
     class GraphQL
       module Base
         class Register < Logic::BaseModel
+          # `filterTags` is a passarray (leaf) that the default DiffService cannot
+          # diff; LeafDiffService detects it as a full-set replace. See
+          # Diffable::LeafDiffService.
+          DIFF_CLASS = Ecoportal::API::Common::GraphQL::Model::Diffable::LeafDiffService
+
           passkey :id
           passthrough :name, :iconName, :moduleType, :registerStatus
           passthrough :descriptionText, :descriptionImageUrl

data/lib/ecoportal/api/graphql/base.rb

@@ -20,13 +20,22 @@ require_relative 'base/page'
 require_relative 'base/resource'
 require_relative 'base/action_category'
 require_relative 'base/action'
+require_relative 'base/action_event_page'
+require_relative 'base/action_event'
 require_relative 'base/contractor_entity'
 require_relative 'base/preview_page'
 require_relative 'base/delta_result'
+require_relative 'base/authorization_result'
+require_relative 'base/permissions'
+require_relative 'base/activity'
+require_relative 'base/activity_log'
+require_relative 'base/auth_log'
+require_relative 'base/person_member_changelog'
 require_relative 'base/organization'
 
 require_relative 'base/register'
 require_relative 'base/preset_view'
+require_relative 'base/minimal_dashboard'
 
 require_relative 'base/ai_summary_version'
 

data/lib/ecoportal/api/graphql/builder/contractor_entity.rb

@@ -21,6 +21,12 @@ module Ecoportal
             destroyMutation.query(**kargs, &block)
           end
 
+          # updateContractorManagerSettings — auto-approval settings + whether
+          # contractor admins may add other admins. Returns the updated Organization.
+          def update_manager_settings(**kargs, &block)
+            updateManagerSettingsMutation.query(**kargs, &block)
+          end
+
           private
 
           def createMutation
@@ -34,6 +40,10 @@ module Ecoportal
           def destroyMutation
             Mutation::ContractorEntity::Destroy.new(client)
           end
+
+          def updateManagerSettingsMutation
+            Mutation::ContractorEntity::UpdateManagerSettings.new(client)
+          end
         end
       end
     end

data/lib/ecoportal/api/graphql/builder/page.rb

@@ -105,14 +105,6 @@ module Ecoportal
             submitAiSummaryFeedbackMutation.query(**kargs, &block)
           end
 
-          def generate_smart_fill(**kargs, &block)
-            generateSmartFillMutation.query(**kargs, &block)
-          end
-
-          def submit_smart_fill_feedback(**kargs, &block)
-            submitSmartFillFeedbackMutation.query(**kargs, &block)
-          end
-
           private
 
           # Blank the page's externalId via updatePage (no patchVer needed — cleanup path).
@@ -184,14 +176,6 @@ module Ecoportal
             Mutation::AiSummary::SubmitFeedback.new(client)
           end
 
-          def generateSmartFillMutation
-            Mutation::SmartFill::Generate.new(client)
-          end
-
-          def submitSmartFillFeedbackMutation
-            Mutation::SmartFill::SubmitFeedback.new(client)
-          end
-
           def executeWorkflowCommandsMutation
             Mutation::Page::ExecuteWorkflowCommands.new(client)
           end

data/lib/ecoportal/api/graphql/builder/template.rb

@@ -40,6 +40,20 @@ module Ecoportal
             )
           end
 
+          # Edits an existing related-pages entry. Only the keys you pass are sent — absent keys
+          # are left alone server-side, so this is a partial update, not a replace.
+          def update_related_page(template_id:, id:, patch_ver:, title: nil, register_id: nil, filters: nil, &block)
+            updateRelatedPageMutation.query(
+              template_id: template_id,
+              id:          id,
+              patch_ver:   patch_ver,
+              title:       title,
+              register_id: register_id,
+              filters:     filters,
+              &block
+            )
+          end
+
           def destroy_related_page(template_id:, id:, patch_ver:, &block)
             destroyRelatedPageMutation.query(template_id: template_id, id: id, patch_ver: patch_ver, &block)
           end
@@ -70,6 +84,10 @@ module Ecoportal
             Mutation::Template::CreateRelatedPage.new(client)
           end
 
+          def updateRelatedPageMutation
+            Mutation::Template::UpdateRelatedPage.new(client)
+          end
+
           def destroyRelatedPageMutation
             Mutation::Template::DestroyRelatedPage.new(client)
           end

data/lib/ecoportal/api/graphql/compat/pages.rb

@@ -18,8 +18,13 @@ module Ecoportal
           # Fetch a page by ID with full data — metadata, stages, sections, data fields.
           # When stage_id is provided, wraps the result in a StageView that filters
           # sections and components to that stage only — matching v2 per-stage behaviour.
-          def get(id, stage_id: nil)
-            page = Query::Page.new(@client).query(id: id) do
+          # @param variables [Hash] optional CommonPageUnion document-variable overrides
+          #   (`showHiddenData:`, `content:`, `only_content:`, `fields:`). `content: false`
+          #   skips field values AND `attachedFiles` — the one selection preauthorized on the
+          #   `files: download` ability — so structure-only readers (e.g. template tooling on a
+          #   least-privilege account) can read pages without that grant.
+          def get(id, stage_id: nil, **variables)
+            page = Query::Page.new(@client).query(id: id, **variables) do
               spread :CommonPageUnion
             end
             stage_id ? StageView.new(page, stage_id) : page

data/lib/ecoportal/api/graphql/compat/response.rb

@@ -5,7 +5,21 @@ module Ecoportal
         # Wraps a GraphQL mutation payload to expose the v2-compatible response interface.
         # Scripts check .success? and .status after update/create operations.
         class Response
+          # The payload contract this wrapper delegates to. Guarded at construction so a
+          # payload of the wrong shape fails LOUD here, instead of silently downstream.
+          # This is the class of drift behind the eco-helpers 3.2.19 KPI-counter
+          # regression, where a Compat::Response (duck-typed, not a Common::Response)
+          # slipped through an `is_a?` check and every GraphQL update went uncounted.
+          PAYLOAD_CONTRACT = %i[success? error? error_doc item].freeze
+
           def initialize(payload)
+            missing = PAYLOAD_CONTRACT.reject { |meth| payload.respond_to?(meth) }
+            unless missing.empty?
+              raise ArgumentError,
+                    "Compat::Response payload #{payload.class} does not honour the expected " \
+                    "response contract; missing: #{missing.join(', ')}"
+            end
+
             @payload = payload
           end
 

data/lib/ecoportal/api/graphql/concerns/threadable.rb

@@ -0,0 +1,58 @@
+module Ecoportal
+  module API
+    class GraphQL
+      module Concerns
+        # Bounded-concurrency helpers for batch operations.
+        #
+        # Ported from `ecoportal-api-v2`'s `Common::Concerns::Threadable` rather than required
+        # from it: that gem is being decommissioned, and this is exactly the kind of small,
+        # stable primitive that should not create a new dependency on it.
+        #
+        # `new_thread` keeps at most `max` threads alive by joining the oldest before starting
+        # a new one — a deliberately simple back-pressure valve, not a pool. `max: 1` runs
+        # inline (no threads at all), which keeps single-file paths and specs deterministic.
+        module Threadable
+          private
+
+          # @param threads [Array<Thread>] the caller's thread accumulator (joined by the caller).
+          # @param max [Integer] maximum concurrent threads; `1` means run inline.
+          # @return [Array<Thread>, void]
+          def new_thread(threads, max: 20, &block)
+            if max <= 1
+              yield
+              return []
+            end
+
+            threads.shift.join if threads.count >= max
+            threads << Thread.new(&block)
+          end
+
+          # Named mutexes, created on demand. Use one key per shared resource so unrelated
+          # critical sections never serialise against each other.
+          def mutex(key = :general)
+            key           = key.to_sym
+            @mutex_map  ||= {}
+            # The map itself must be created atomically the first time.
+            @mutex_map[key] ||= Mutex.new
+          end
+
+          # Batch work must not be killed by one file raising in a thread, and must not spam
+          # the caller's stderr with per-thread reports — the caller gets the error in its
+          # result object instead. Restores both globals afterwards.
+          def with_preserved_thread_globals(abort: false, report: false)
+            mutex(:thread_globals).synchronize do
+              prev_abort  = Thread.abort_on_exception
+              prev_report = Thread.report_on_exception
+              Thread.abort_on_exception  = abort
+              Thread.report_on_exception = report
+              yield
+            ensure
+              Thread.abort_on_exception  = prev_abort
+              Thread.report_on_exception = prev_report
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ecoportal/api/graphql/concerns.rb

@@ -12,3 +12,4 @@ require_relative 'concerns/fragment_definitions'
 require_relative 'concerns/snake_camel_access'
 require_relative 'concerns/page_compat'
 require_relative 'concerns/data_field_access'
+require_relative 'concerns/threadable'

data/lib/ecoportal/api/graphql/connection/action.rb

@@ -3,7 +3,7 @@ module Ecoportal
     class GraphQL
       module Connection
         class Action < Logic::Connection
-          class_resolver :node_class, Model::Action
+          nodes_of Model::Action
         end
       end
     end

data/lib/ecoportal/api/graphql/connection/action_category.rb

@@ -3,7 +3,7 @@ module Ecoportal
     class GraphQL
       module Connection
         class ActionCategory < Logic::Connection
-          class_resolver :node_class, Base::ActionCategory
+          nodes_of Base::ActionCategory
         end
       end
     end

data/lib/ecoportal/api/graphql/connection/activity.rb

@@ -0,0 +1,11 @@
+module Ecoportal
+  module API
+    class GraphQL
+      module Connection
+        class Activity < Logic::Connection
+          nodes_of Model::Activity
+        end
+      end
+    end
+  end
+end

data/lib/ecoportal/api/graphql/connection/activity_log.rb

@@ -0,0 +1,11 @@
+module Ecoportal
+  module API
+    class GraphQL
+      module Connection
+        class ActivityLog < Logic::Connection
+          nodes_of Model::ActivityLog
+        end
+      end
+    end
+  end
+end

data/lib/ecoportal/api/graphql/connection/auth_log.rb

@@ -0,0 +1,11 @@
+module Ecoportal
+  module API
+    class GraphQL
+      module Connection
+        class AuthLog < Logic::Connection
+          nodes_of Model::AuthLog
+        end
+      end
+    end
+  end
+end

data/lib/ecoportal/api/graphql/connection/contractor_entity.rb

@@ -3,7 +3,7 @@ module Ecoportal
     class GraphQL
       module Connection
         class ContractorEntity < Logic::Connection
-          class_resolver :node_class, Model::ContractorEntity
+          nodes_of Model::ContractorEntity
         end
       end
     end

data/lib/ecoportal/api/graphql/connection/minimal_dashboard.rb

@@ -0,0 +1,11 @@
+module Ecoportal
+  module API
+    class GraphQL
+      module Connection
+        class MinimalDashboard < Logic::Connection
+          nodes_of Model::MinimalDashboard
+        end
+      end
+    end
+  end
+end

data/lib/ecoportal/api/graphql/connection/page.rb

@@ -3,7 +3,7 @@ module Ecoportal
     class GraphQL
       module Connection
         class Page < Logic::Connection
-          class_resolver :node_class, 'Ecoportal::API::GraphQL::Model::PageUnion'
+          nodes_of 'Ecoportal::API::GraphQL::Model::PageUnion'
         end
       end
     end

data/lib/ecoportal/api/graphql/connection/pages_workflow_command.rb

@@ -5,7 +5,7 @@ module Ecoportal
         class PagesWorkflowCommand < Logic::Connection
           SCHEMA_VERSION = '20260605'.freeze
 
-          class_resolver :node_class, 'Ecoportal::API::GraphQL::Base::PagesWorkflow::CommandInterface'
+          nodes_of 'Ecoportal::API::GraphQL::Base::PagesWorkflow::CommandInterface'
         end
       end
     end

data/lib/ecoportal/api/graphql/connection/person_member.rb

@@ -3,7 +3,7 @@ module Ecoportal
     class GraphQL
       module Connection
         class PersonMemberConnection < Logic::Connection
-          class_resolver :node_class, Model::PersonMember
+          nodes_of Model::PersonMember
         end
       end
     end

data/lib/ecoportal/api/graphql/connection/person_member_changelog.rb

@@ -0,0 +1,11 @@
+module Ecoportal
+  module API
+    class GraphQL
+      module Connection
+        class PersonMemberChangelog < Logic::Connection
+          nodes_of Model::PersonMemberChangelog
+        end
+      end
+    end
+  end
+end

data/lib/ecoportal/api/graphql/connection/preview_page.rb

@@ -3,7 +3,7 @@ module Ecoportal
     class GraphQL
       module Connection
         class PreviewPage < Logic::Connection
-          class_resolver :node_class, 'Ecoportal::API::GraphQL::Model::PreviewPage'
+          nodes_of 'Ecoportal::API::GraphQL::Model::PreviewPage'
         end
       end
     end

data/lib/ecoportal/api/graphql/connection.rb

@@ -15,3 +15,8 @@ require_relative 'connection/page'
 require_relative 'connection/preview_page'
 require_relative 'connection/preset_view'
 require_relative 'connection/pages_workflow_command'
+require_relative 'connection/activity'
+require_relative 'connection/activity_log'
+require_relative 'connection/auth_log'
+require_relative 'connection/person_member_changelog'
+require_relative 'connection/minimal_dashboard'

data/lib/ecoportal/api/graphql/diff/pairing/signals.rb

@@ -25,13 +25,33 @@ module Ecoportal
             # MISMATCH scores 0 rather than vetoing (the field may have been re-purposed keeping its
             # genome, or genome may be absent on newer field types). Returns nil when neither side
             # carries a genome — the signal simply does not apply and is excluded from the average.
+            #
+            # LINEAGE (verified live 2026-08-05, same-org backup restore of a full template): a
+            # restore does NOT equal-copy the signature — it APPENDS one segment to it, for every
+            # membrane AND force (e.g. `2zwxkb6gns` → `2zwxkb6gns53jp`, `ktnrya` → `ktnrya877l`;
+            # 28/28 fields + 4/4 forces followed the rule). So an ancestor's signature is a strict
+            # PREFIX of its descendant's, and equality-only scoring would give the exact
+            # cross-object case this engine exists for (UAT backup → PROD restore) a 0.0 — worse
+            # than no signal. Prefix ancestry therefore scores just below an exact match.
             def genome(source, target)
               a = source['genomeSignature']
               b = target['genomeSignature']
               return nil if blank?(a) && blank?(b)
               return 0.0 if blank?(a) || blank?(b)
+              return 1.0 if a == b
 
-              a == b ? 1.0 : 0.0
+              lineage?(a, b) ? 0.9 : 0.0
+            end
+
+            # True when one signature is a strict prefix of the other (restore/copy appends a
+            # lineage segment — see #genome). Direction is unknowable at a pairing call (either
+            # side may be the older document), so both directions count. Very short signatures
+            # are rejected as ancestry evidence — a trivial prefix can collide by chance.
+            def lineage?(sig_a, sig_b)
+              short, long = [sig_a.to_s, sig_b.to_s].minmax_by(&:length)
+              return false if short.length < 4
+
+              short != long && long.start_with?(short)
             end
 
             # Field type (__typename) equality. A type change is a strong DISQUALIFIER for a data