ecoportal-api-graphql 1.3.17 → 2.2.1

data/lib/ecoportal/api/graphql/input/workflow_command/move_section_to_stage.rb

@@ -0,0 +1,33 @@
+module Ecoportal
+  module API
+    class GraphQL
+      module Input
+        class WorkflowCommand
+          # `WorkflowMoveSectionToStageInput` (20260929) -- moves an existing section from one
+          # stage to another, optionally placed relative to an anchor section. Unlike
+          # `reorderSection` (same stage), the source and target stages are both required.
+          module MoveSectionToStage
+            SCHEMA_VERSION = '20260929'.freeze
+            VALID_KEYS = %i[sourceStageId targetStageId sectionId anchorId anchorPosition].freeze
+            ANCHOR_POSITIONS = AddViewableField::ANCHOR_POSITIONS
+
+            def self.build(source_stage_id:, target_stage_id:, section_id:, **kwargs)
+              position = kwargs[:anchorPosition]
+              unless position.nil? || ANCHOR_POSITIONS.include?(position.to_s)
+                raise ArgumentError,
+                      "Invalid anchorPosition #{position.inspect}: " \
+                      "expected one of #{ANCHOR_POSITIONS.join(', ')}"
+              end
+
+              {
+                sourceStageId: source_stage_id,
+                targetStageId: target_stage_id,
+                sectionId:     section_id
+              }.merge(kwargs.slice(:anchorId, :anchorPosition).compact)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ecoportal/api/graphql/input/workflow_command/move_viewable_field.rb

@@ -0,0 +1,33 @@
+module Ecoportal
+  module API
+    class GraphQL
+      module Input
+        class WorkflowCommand
+          # `WorkflowMoveViewableFieldInput` — reorders a viewable field on a People data field.
+          # Same shape as AddViewableField minus `schemaFieldType` (the field already exists, so
+          # its type is known server-side). See AddViewableField for why these three commands
+          # replaced the removed `people.add/removeViewableFields` arrays.
+          module MoveViewableField
+            SCHEMA_VERSION = '20260725'.freeze
+            VALID_KEYS = %i[dataFieldId schemaFieldId anchorId anchorPosition].freeze
+            ANCHOR_POSITIONS = AddViewableField::ANCHOR_POSITIONS
+
+            def self.build(data_field_id:, schema_field_id:, **kwargs)
+              position = kwargs[:anchorPosition]
+              unless position.nil? || ANCHOR_POSITIONS.include?(position.to_s)
+                raise ArgumentError,
+                      "Invalid anchorPosition #{position.inspect}: " \
+                      "expected one of #{ANCHOR_POSITIONS.join(', ')}"
+              end
+
+              {
+                dataFieldId:   data_field_id,
+                schemaFieldId: schema_field_id
+              }.merge(kwargs.slice(:anchorId, :anchorPosition).compact)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ecoportal/api/graphql/input/workflow_command/remove_checklist_field_item.rb

@@ -0,0 +1,19 @@
+module Ecoportal
+  module API
+    class GraphQL
+      module Input
+        class WorkflowCommand
+          # 20260713
+          module RemoveChecklistFieldItem
+            SCHEMA_VERSION = '20260713'.freeze
+            VALID_KEYS = %i[dataFieldId itemId].freeze
+
+            def self.build(**kwargs)
+              kwargs.slice(*VALID_KEYS).compact
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ecoportal/api/graphql/input/workflow_command/remove_smart_fill_config.rb

@@ -0,0 +1,19 @@
+module Ecoportal
+  module API
+    class GraphQL
+      module Input
+        class WorkflowCommand
+          # 20260713
+          module RemoveSmartFillConfig
+            SCHEMA_VERSION = '20260713'.freeze
+            VALID_KEYS = %i[dataFieldId].freeze
+
+            def self.build(**kwargs)
+              kwargs.slice(*VALID_KEYS).compact
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ecoportal/api/graphql/input/workflow_command/remove_viewable_field.rb

@@ -0,0 +1,21 @@
+module Ecoportal
+  module API
+    class GraphQL
+      module Input
+        class WorkflowCommand
+          # `WorkflowRemoveViewableFieldInput` — removes a viewable field from a People data
+          # field. Both keys are required (`ID!`). Replaces the removed
+          # `people.removeViewableFields` array — see AddViewableField.
+          module RemoveViewableField
+            SCHEMA_VERSION = '20260725'.freeze
+            VALID_KEYS = %i[dataFieldId schemaFieldId].freeze
+
+            def self.build(data_field_id:, schema_field_id:)
+              { dataFieldId: data_field_id, schemaFieldId: schema_field_id }
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ecoportal/api/graphql/input/workflow_command/reorder_forces.rb

@@ -4,8 +4,9 @@ module Ecoportal
       module Input
         class WorkflowCommand
           module ReorderForces
-            SCHEMA_VERSION = '20260605'.freeze
-            VALID_KEYS = %i[forceId after before].freeze
+            SCHEMA_VERSION = '20260713'.freeze
+            # 20260713: `after`/`before` replaced by anchor-based positioning.
+            VALID_KEYS = %i[forceId anchorId anchorPosition].freeze
 
             def self.build(**kwargs)
               kwargs.slice(*VALID_KEYS).compact

data/lib/ecoportal/api/graphql/input/workflow_command/reorder_section.rb

@@ -4,8 +4,9 @@ module Ecoportal
       module Input
         class WorkflowCommand
           module ReorderSection
-            SCHEMA_VERSION = '20260605'.freeze
-            VALID_KEYS = %i[sectionId stageId after before].freeze
+            SCHEMA_VERSION = '20260713'.freeze
+            # 20260713: `after`/`before` replaced by anchor-based positioning.
+            VALID_KEYS = %i[sectionId stageId anchorId anchorPosition].freeze
 
             def self.build(**kwargs)
               kwargs.slice(*VALID_KEYS).compact

data/lib/ecoportal/api/graphql/input/workflow_command.rb

@@ -6,9 +6,19 @@ module Ecoportal
           SCHEMA_VERSION = '20260605'.freeze
 
           COMMAND_MAP = {
-            # Page-level
-            editPage:                          'Ecoportal::API::GraphQL::Input::WorkflowCommand::EditPage',
-            editPageCreatorPermissions:        'Ecoportal::API::GraphQL::Input::WorkflowCommand::EditPageCreatorPermissions',
+            # Template settings (20260713 — supersede the removed page-level editPage/editPageCreatorPermissions)
+            editTemplateBasicSettings:         'Ecoportal::API::GraphQL::Input::WorkflowCommand::EditTemplateBasicSettings',
+            editTemplateAdvancedSettings:      'Ecoportal::API::GraphQL::Input::WorkflowCommand::EditTemplateAdvancedSettings',
+            editTemplateCreatorPermissions:    'Ecoportal::API::GraphQL::Input::WorkflowCommand::EditTemplateCreatorPermissions',
+            editTemplateDescriptions:          'Ecoportal::API::GraphQL::Input::WorkflowCommand::EditTemplateDescriptions',
+            # Cross-version template identity (the series key) — see the input class for the
+            # publish-swap rule that makes it usable as an entity id across versions.
+            editTemplateContainerUid:          'Ecoportal::API::GraphQL::Input::WorkflowCommand::EditTemplateContainerUid',
+            createPublicConfig:                'Ecoportal::API::GraphQL::Input::WorkflowCommand::CreatePublicConfig',
+            editPublicConfig:                  'Ecoportal::API::GraphQL::Input::WorkflowCommand::EditPublicConfig',
+            archivePublicConfig:               'Ecoportal::API::GraphQL::Input::WorkflowCommand::ArchivePublicConfig',
+            # Copy-page configuration (20260819)
+            manageCopyPageConfiguration:       'Ecoportal::API::GraphQL::Input::WorkflowCommand::ManageCopyPageConfiguration',
             # Stage structural
             addStage:                          'Ecoportal::API::GraphQL::Input::WorkflowCommand::AddStage',
             removeStage:                       'Ecoportal::API::GraphQL::Input::WorkflowCommand::RemoveStage',
@@ -33,6 +43,7 @@ module Ecoportal
             collapseSection:                   'Ecoportal::API::GraphQL::Input::WorkflowCommand::CollapseSection',
             expandSection:                     'Ecoportal::API::GraphQL::Input::WorkflowCommand::ExpandSection',
             reorderSection:                    'Ecoportal::API::GraphQL::Input::WorkflowCommand::ReorderSection',
+            moveSectionToStage:                'Ecoportal::API::GraphQL::Input::WorkflowCommand::MoveSectionToStage',
             # Task
             addTask:                           'Ecoportal::API::GraphQL::Input::WorkflowCommand::AddTask',
             removeTask:                        'Ecoportal::API::GraphQL::Input::WorkflowCommand::RemoveTask',
@@ -91,6 +102,19 @@ module Ecoportal
             removeField:                       'Ecoportal::API::GraphQL::Input::WorkflowCommand::RemoveField',
             # Field config
             editFieldConfiguration:            'Ecoportal::API::GraphQL::Input::WorkflowCommand::EditFieldConfiguration',
+            # Viewable fields on People data fields (20260725) — replaced the REMOVED
+            # `people.addViewableFields`/`removeViewableFields` arrays; see AddViewableField.
+            addViewableField:                  'Ecoportal::API::GraphQL::Input::WorkflowCommand::AddViewableField',
+            moveViewableField:                 'Ecoportal::API::GraphQL::Input::WorkflowCommand::MoveViewableField',
+            removeViewableField:               'Ecoportal::API::GraphQL::Input::WorkflowCommand::RemoveViewableField',
+            # Checklist field items (20260713)
+            addChecklistFieldItem:             'Ecoportal::API::GraphQL::Input::WorkflowCommand::AddChecklistFieldItem',
+            editChecklistFieldItem:            'Ecoportal::API::GraphQL::Input::WorkflowCommand::EditChecklistFieldItem',
+            removeChecklistFieldItem:          'Ecoportal::API::GraphQL::Input::WorkflowCommand::RemoveChecklistFieldItem',
+            # Smart-fill config (20260713 — extracted from field-config inputs)
+            addSmartFillConfig:                'Ecoportal::API::GraphQL::Input::WorkflowCommand::AddSmartFillConfig',
+            editSmartFillConfig:               'Ecoportal::API::GraphQL::Input::WorkflowCommand::EditSmartFillConfig',
+            removeSmartFillConfig:             'Ecoportal::API::GraphQL::Input::WorkflowCommand::RemoveSmartFillConfig',
             # Select options
             addSelectFieldOption:              'Ecoportal::API::GraphQL::Input::WorkflowCommand::AddSelectFieldOption',
             editSelectFieldOption:             'Ecoportal::API::GraphQL::Input::WorkflowCommand::EditSelectFieldOption',
@@ -147,8 +171,21 @@ module Ecoportal
   end
 end
 
-require_relative 'workflow_command/edit_page'
-require_relative 'workflow_command/edit_page_creator_permissions'
+require_relative 'workflow_command/edit_template_basic_settings'
+require_relative 'workflow_command/edit_template_advanced_settings'
+require_relative 'workflow_command/edit_template_creator_permissions'
+require_relative 'workflow_command/edit_template_descriptions'
+require_relative 'workflow_command/edit_template_container_uid'
+require_relative 'workflow_command/create_public_config'
+require_relative 'workflow_command/edit_public_config'
+require_relative 'workflow_command/archive_public_config'
+require_relative 'workflow_command/manage_copy_page_configuration'
+require_relative 'workflow_command/add_checklist_field_item'
+require_relative 'workflow_command/edit_checklist_field_item'
+require_relative 'workflow_command/remove_checklist_field_item'
+require_relative 'workflow_command/add_smart_fill_config'
+require_relative 'workflow_command/edit_smart_fill_config'
+require_relative 'workflow_command/remove_smart_fill_config'
 require_relative 'workflow_command/add_stage'
 require_relative 'workflow_command/remove_stage'
 require_relative 'workflow_command/edit_stage'
@@ -237,9 +274,15 @@ require_relative 'workflow_command/remove_binding'
 require_relative 'workflow_command/add_linked_helper'
 require_relative 'workflow_command/edit_linked_helper'
 require_relative 'workflow_command/remove_linked_helper'
+require_relative 'workflow_command/add_viewable_field'
+require_relative 'workflow_command/move_viewable_field'
+require_relative 'workflow_command/move_section_to_stage'
+require_relative 'workflow_command/remove_viewable_field'
+require_relative 'workflow_command/field_config/action_list'
 require_relative 'workflow_command/field_config/contractor_entities'
 require_relative 'workflow_command/field_config/cross_reference'
 require_relative 'workflow_command/field_config/date'
+require_relative 'workflow_command/field_config/file'
 require_relative 'workflow_command/field_config/gauge'
 require_relative 'workflow_command/field_config/image_gallery'
 require_relative 'workflow_command/field_config/location_field'

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

@@ -16,6 +16,7 @@ require_relative 'input/contractor_entity'
 require_relative 'input/action'
 require_relative 'input/page'
 require_relative 'input/delta_input'
+require_relative 'input/date_range'
 require_relative 'input/search_conf'
 
 require_relative 'input/register'

data/lib/ecoportal/api/graphql/interface/base_page.rb

@@ -6,6 +6,12 @@ module Ecoportal
           include Concerns::PageCompat
           include Concerns::DataFieldAccess
 
+          # Page-level leaf arrays (`otherTags`, whole-set `locations`) are cascaded
+          # attributes the default DiffService cannot see. LeafDiffService diffs them
+          # inline (full-set replace) while still cascading into real nested models
+          # (e.g. a phased page's `stages`). See Diffable::LeafDiffService.
+          DIFF_CLASS = Ecoportal::API::Common::GraphQL::Model::Diffable::LeafDiffService
+
           passkey :id
           passthrough :name, :uid
           passthrough :icon
@@ -15,7 +21,6 @@ module Ecoportal
           # class_resolver :force_class, 'Ecoportal::API::GraphQL::Base::Force'
           # class_resolver :task_class, 'Ecoportal::API::GraphQL::Interface::Task'
           # class_resolver :theme_class, 'Ecoportal::API::GraphQL::Base::Theme'
-          # class_resolver :template_class, 'Ecoportal::API::GraphQL::Base::Template'
           # class_resolver :register_class, 'Ecoportal::API::GraphQL::Base::Register'
           class_resolver :organization_class, 'Ecoportal::API::GraphQL::Base::Organization'
 
@@ -32,6 +37,20 @@ module Ecoportal
             Array(doc['locations']).map { |l| l.is_a?(Hash) ? l['id'] : l }.compact
           end
 
+          # Compiled tag set (client-side build of the backend-only "compiled_tags").
+          # This base implementation covers a non-phased page (and is the fallback for a
+          # phased page with no stages): there are no per-stage tags, so the set is just the
+          # page-level components, de-duplicated:
+          #
+          #   all_tags = Unique(baseTags + otherTags + location_ids)
+          #
+          # Model::Page::Phased overrides this to take the union across its stages' #all_tags.
+          # Returns a de-duplicated Array of tag strings.
+          def all_tags
+            (Array(baseTags) + Array(otherTags) + Array(location_ids)).
+              compact.uniq
+          end
+
           def location_ids=(ids)
             doc['locations'] = Array(ids).map { |id_val| { 'id' => id_val } }
           end
@@ -41,7 +60,6 @@ module Ecoportal
           # embeds_one :taskPriority, klass: 'BasePage::TaskPriorityEnum', read_only: true
           passthrough :taskPriority
 
-
           passthrough :patchVer
 
           passboolean :draft, :archived
@@ -78,7 +96,36 @@ module Ecoportal
           # the CreateFromTemplateInput preview. nil for fetched/persisted pages.
           attr_accessor :_compat_source_template_id
 
-          # embeds_one :template, klass: :template_class, read_only: true
+          # The narrow `Template` type (NOT the template page — see Base::Template for the
+          # asymmetry). Populated only for template pages; nil for records. Carries
+          # `templateContainerUid`, the cross-version series key.
+          class_resolver :template_class, 'Ecoportal::API::GraphQL::Model::Template::Information'
+
+          # Deliberately NOT `embeds_one ..., read_only: true`, and this is not a style choice:
+          # `read_only` does not keep a mutated child out of the parent's diff. With `embeds_one`,
+          # `page.template.templateContainerUid = 'x'` yields
+          # `as_update => { id:, template: { templateContainerUid: 'x' } }` — but `UpdatePageInput`
+          # has NO `template` member, so that would push a key `updatePage` cannot accept. The
+          # only writer for the series key is the `editTemplateContainerUid` workflow command.
+          #
+          # So this follows the same on-demand read-only pattern as `#forces` above, over a COPY of
+          # the sub-doc: the returned model is a genuine dead end — writes to it cannot reach
+          # `doc`, cannot dirty the page, and cannot leak into an update.
+          def template
+            return nil unless (raw = doc['template'])
+
+            @template ||= template_class.new(
+              Ecoportal::API::Common::GraphQL::HashHelpers.deep_dup(raw)
+            )
+          end
+
+          # Convenience reader for the cross-version series key — nil unless this page is a
+          # template AND the read selected `template { templateContainerUid }` (CommonPageUnion
+          # does). Many versions may share one uid; only one may be published at a time.
+          def templateContainerUid
+            template&.templateContainerUid
+          end
+
           # embeds_many :registers, klass: :register_class, read_only: true
           # embeds_one :organization, klass: :organization_class, read_only: true
 

data/lib/ecoportal/api/graphql/interface/location_structure/command.rb

@@ -17,7 +17,8 @@ module Ecoportal
 
             def set_values(**kargs)
               kargs.each do |key, value|
-                send(key, value) if respond_to?(key, true)
+                writer = "#{key}="
+                send(writer, value) if respond_to?(writer, true)
               end
 
               self

data/lib/ecoportal/api/graphql/logic/base_query.rb

@@ -140,14 +140,81 @@ module Ecoportal
                 raw_response[:data] = response
               end
             end
-          rescue *DETAIL_ERRORS => _err
-            pp kargs
-            puts "Internal Error with these params:\n"
-            pp query_params
-            pp block
+          rescue *DETAIL_ERRORS => err
+            report_query_failure(err, query_params)
             raise
           end
 
+          # Reports WHERE a query failed, on stderr, and re-raises untouched.
+          #
+          # ★ This replaces an unconditional `pp kargs` / `pp query_params` / `pp block`
+          # to STDOUT. That dump was NOT debug litter — it existed because graphlient
+          # masks the origin of a failure: `Client#parse`/`#execute` do
+          # `raise Graphlient::Errors::ClientError, e.message`, which leaves graphlient's
+          # own `inner_exception` nil AND replaces the backtrace, discarding the source
+          # location `graphql-client` deliberately sets via
+          # `set_backtrace(["#{filename}:#{line}"])`. With that gone there was no other
+          # way to see which query blew up. (Tracked upstream; see
+          # the repo's internal docs.)
+          #
+          # But the location was never actually destroyed. Ruby populates `.cause`
+          # automatically when you raise inside a rescue, so the original error — with the
+          # location intact — is one hop away. Verified by execution:
+          #
+          #   err.inner_exception        => nil                    (graphlient's api, broken)
+          #   err.backtrace.first        => ".../client.rb:20"     (the raise site, useless)
+          #   err.cause.backtrace.first  => "app/queries/x.rb:198" (the QUERY site)
+          #
+          # So this reports MORE of what the dump was for (the failing query's own source
+          # location) and LESS of what it should never have emitted: `query_params` holds
+          # GraphQL variables — page ids, emails, field values — and printing them to
+          # stdout put customer data into CI logs. Variables are now shown only when the
+          # client's existing `deep_logging` flag is on (see `dump_variables?` for why NOT
+          # the logger level). `pp block` is dropped outright: inspecting a Proc never
+          # identified anything.
+          #
+          # Emitted with `warn` (stderr, and suppressible via the Warning module) rather than
+          # `puts`, so tools that pipe query results keep a clean stdout. Tracked as Q-43.
+          def report_query_failure(err, query_params = nil)
+            origin = err.cause
+            lines  = ["[#{self.class.name || self.class}] #{err.class}: #{failure_message(err)}"]
+            lines << "  origin: #{origin.class}" if origin
+            lines << "  at:     #{origin.backtrace.first}" if origin&.backtrace&.first
+            lines << "  params: #{query_params.inspect}" if dump_variables?
+
+            warn(lines.join("\n"))
+          end
+
+          # graphlient's `GraphQLError#to_s` / `ExecutionError#to_s` format from
+          # `errors.details` and render an EMPTY string when that is empty — and because
+          # they override `to_s`, the fallback text their constructors pass to `super` is
+          # unreachable. An exception with a blank message is invisible in a log, so say
+          # so rather than printing nothing.
+          def failure_message(err)
+            msg = err.message.to_s
+            return msg unless msg.empty?
+
+            "(blank — #{err.class} renders its message from errors.details, which was empty)"
+          end
+
+          # Opt-in via the client's EXISTING `deep_logging` flag ("whether or not batch
+          # responses should be logged") — the same class of thing as dumping variables,
+          # and it defaults to false. No new env var and no new config knob.
+          #
+          # ⚠ Do NOT gate this on `logger.debug?`, which is the obvious-looking choice and
+          # is wrong: `HttpClient`'s default logger is `::Logger.new(IO::NULL)`, and a
+          # fresh Logger's level is DEBUG (0) — so `logger.debug?` is `true` out of the
+          # box and variables would leak by default, which is the whole thing being fixed.
+          # A spec pins this.
+          def dump_variables?
+            http = client&.http_client
+            return false unless http.respond_to?(:deep_logging?, true)
+
+            !!http.send(:deep_logging?)
+          rescue StandardError
+            false
+          end
+
           def request(*path)
             response = yield
             wrap_response(response, path)

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

@@ -18,6 +18,23 @@ module Ecoportal
           embeds_many :nodes, klass: :node_class
           embeds_one :pageInfo, klass: Base::PageInfo
 
+          # Bind a connection subclass to its concrete node type.
+          #
+          # The base `embeds_many :nodes, klass: :node_class` builds a SINGLE dynamic
+          # `CollectionModel` ("nodes::node_class") that every subclass inherits and shares.
+          # The v2 collection layer memoizes the resolved class on that shared collection
+          # (items_klass.rb:62-63), so the FIRST connection instantiated in a process poisons
+          # every other connection's instance `nodes` typing (e.g. a MinimalDashboard connection
+          # returning AuthLog nodes). Declaring `embeds_many :nodes` per subclass with the concrete
+          # class gives each subclass its OWN collection ("nodes::Model::X") bound to a real Class —
+          # no shared symbol, nothing to memoize wrongly.
+          #
+          # Use `nodes_of Model::X` in a subclass instead of `class_resolver :node_class, Model::X`.
+          def self.nodes_of(klass)
+            class_resolver :node_class, klass
+            embeds_many :nodes, klass: klass
+          end
+
           def empty?
             count < 1
           end

data/lib/ecoportal/api/graphql/logic/input.rb

@@ -5,6 +5,133 @@ module Ecoportal
         class Input < Logic::BaseModel
           passthrough :clientMutationId
 
+          # Declarative set-diff macro for id-list fields that the schema exposes as
+          # `IdDiffInput { additions: [ID!], removals: [ID!] }` on the *update* mutation.
+          #
+          # Mixed into any Input class (whether it inherits from {Logic::Input} or from a
+          # `Base::` data model) via `extend`. {Logic::Input} extends it for its own subclasses;
+          # data-model Input classes call `extend Logic::Input::IdDiffFields` explicitly.
+          #
+          # Usage:
+          #   class Update < Base::ContractorEntity
+          #     extend Logic::Input::IdDiffFields
+          #     id_diff_fields :associatedPeopleIds, :leadContractorIds
+          #   end
+          #
+          # It installs (or augments) a `from_model` that, for each declared field, computes the
+          # delta DIRECTLY from the READ model's `doc[key]` vs `original_doc[key]` arrays:
+          #   additions = current - original
+          #   removals  = original - current
+          # A field is omitted when unchanged. The delta is computed directly (NOT via the
+          # cascaded DiffService) because these array fields are dropped from the flat diff and
+          # the read model is `root!` (so its doc/original_doc resolve without cascade side effects).
+          module IdDiffFields
+            # @return [Array<Symbol>] the fields declared for set-diff on this class.
+            def id_diff_fields_list
+              @id_diff_fields_list ||= []
+            end
+
+            # Declares the id-list fields that must be reshaped into IdDiff `{ additions:, removals: }`.
+            # @param fields [Array<Symbol>] field names (as they appear in the read model's doc).
+            # @return [void]
+            def id_diff_fields(*fields)
+              id_diff_fields_list.concat(fields.flatten.map(&:to_sym)).uniq!
+            end
+
+            # Computes the IdDiff-shaped deltas for the declared fields and merges them into +diff+.
+            # @param model [Common::GraphQL::Model] the subject (read) model.
+            # @param diff [Hash, nil] the base mutation input hash to augment (may be nil).
+            # @return [Hash, nil] +diff+ with per-field `{ additions:, removals: }` merged in,
+            #   or the original value when nothing changed.
+            def merge_id_diffs(model, diff)
+              id_diff_fields_list.each do |field|
+                key      = field.to_s
+                current  = Array(model.doc[key])
+                original = Array(model.original_doc[key])
+                next if current == original
+
+                diff        ||= {}
+                diff[:id]   ||= model.id if model.respond_to?(:id)
+                diff[field]   = { additions: current - original, removals: original - current }
+              end
+              diff
+            end
+
+            # Reshaping `from_model`: base diff (via {Logic::Input.from_model}) + set-diff deltas.
+            # @param model [Common::GraphQL::Model] the subject model.
+            # @return [Hash, nil] the mutation input hash, or nil when there are no changes.
+            def from_model(model, **kargs)
+              diff = Logic::Input.from_model(model, **kargs)
+              merge_id_diffs(model, diff)
+            end
+          end
+
+          # Declarative FULL-ARRAY macro for id-list fields that the schema exposes as a plain
+          # `[ID!]` on the *update* mutation (NOT `IdDiffInput`). The server expects the COMPLETE
+          # current array, replacing the stored value wholesale — there is no additions/removals
+          # delta shape. This is the counterpart to {IdDiffFields}.
+          #
+          # Mixed into any Input class via `extend`, exactly like {IdDiffFields}. Data-model Input
+          # classes call `extend Logic::Input::FullArrayFields` explicitly.
+          #
+          # Usage:
+          #   class Update < Base::Action
+          #     extend Logic::Input::FullArrayFields
+          #     full_array_fields :assignedPersonMemberIds, :locationIds, :fileContainerIds
+          #   end
+          #
+          # It installs (or augments) a `from_model` that, for each declared field, emits the FULL
+          # current array taken DIRECTLY from the READ model's `doc[key]` whenever it differs from
+          # `original_doc[key]`. A field is omitted when unchanged. The value is read directly (NOT
+          # via the cascaded DiffService) because these array fields are dropped from the flat diff
+          # and the read model is `root!`.
+          #
+          # Schema evidence (live introspection 20260605, UpdateActionInput):
+          #   assignedPersonMemberIds : [ID!]
+          #   locationIds             : [ID!]
+          #   fileContainerIds        : [ID!]
+          # None are `IdDiffInput` — hence full-array, not delta.
+          module FullArrayFields
+            # @return [Array<Symbol>] the fields declared for full-array emission on this class.
+            def full_array_fields_list
+              @full_array_fields_list ||= []
+            end
+
+            # Declares the id-list fields that must be emitted as their COMPLETE current array.
+            # @param fields [Array<Symbol>] field names (as they appear in the read model's doc).
+            # @return [void]
+            def full_array_fields(*fields)
+              full_array_fields_list.concat(fields.flatten.map(&:to_sym)).uniq!
+            end
+
+            # Emits the full current array for each changed declared field and merges it into +diff+.
+            # @param model [Common::GraphQL::Model] the subject (read) model.
+            # @param diff [Hash, nil] the base mutation input hash to augment (may be nil).
+            # @return [Hash, nil] +diff+ with per-field full arrays merged in, or the original
+            #   value when nothing changed.
+            def merge_full_arrays(model, diff)
+              full_array_fields_list.each do |field|
+                key      = field.to_s
+                current  = Array(model.doc[key])
+                original = Array(model.original_doc[key])
+                next if current == original
+
+                diff        ||= {}
+                diff[:id]   ||= model.id if model.respond_to?(:id)
+                diff[field]   = current
+              end
+              diff
+            end
+
+            # Reshaping `from_model`: base diff (via {Logic::Input.from_model}) + full arrays.
+            # @param model [Common::GraphQL::Model] the subject model.
+            # @return [Hash, nil] the mutation input hash, or nil when there are no changes.
+            def from_model(model, **kargs)
+              diff = Logic::Input.from_model(model, **kargs)
+              merge_full_arrays(model, diff)
+            end
+          end
+
           class << self
             # Builds a mutation input hash from a model's diff.
             # Subclasses override this to reshape fields (e.g. array → IdDiffInput).

data/lib/ecoportal/api/graphql/model/action_event.rb

@@ -0,0 +1,14 @@
+module Ecoportal
+  module API
+    class GraphQL
+      module Model
+        class ActionEvent < Base::ActionEvent
+          # assignedPersonMembers: [PreviewPersonMember!]! — Model::PersonMember's
+          # read fields are a compatible superset.
+          embeds_many :assignedPersonMembers, klass: Model::PersonMember
+          embeds_many :pages, klass: "Ecoportal::API::GraphQL::Model::ActionEventPage"
+        end
+      end
+    end
+  end
+end

data/lib/ecoportal/api/graphql/model/action_event_page.rb

@@ -0,0 +1,10 @@
+module Ecoportal
+  module API
+    class GraphQL
+      module Model
+        class ActionEventPage < Base::ActionEventPage
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,14 @@
+module Ecoportal
+  module API
+    class GraphQL
+      module Model
+        # Concrete read model for a page activity/history entry. Adds the
+        # relational embeds on top of the common interface fields in Base::Activity.
+        class Activity < Base::Activity
+          embeds_one :personMember, klass: Model::PersonMember, nullable: true
+          embeds_one :user, klass: Model::User, nullable: true
+        end
+      end
+    end
+  end
+end