ecoportal-api-graphql 1.3.17 → 2.2.1

data/lib/ecoportal/api/graphql/base/page/data_field/file_field.rb

@@ -1,24 +1,63 @@
 module Ecoportal::API::GraphQL::Base::Page
   class DataField
     # File attachment field.
-    # Writing requires a prior file upload to the REST upload endpoint
-    # to obtain fileContainerIds — see the file-upload TODO in projects/TODO.md.
-    # The file_container_ids= setter can be used once IDs are available.
+    # READ: the fragment selects `items { id fileContainer { id ... } }` — the container id
+    # lives at items[].fileContainer.id, NOT in a `fileContainers` array (live-verified;
+    # the previous reader keyed on a doc key the API never returns).
+    # WRITE: live `FileInput` accepts `items: [ItemInput]` ({id, fileContainerId, position}),
+    # NOT `fileContainerIds`. The backend applies `items` as FULL-REPLACE — any existing item
+    # whose id is not echoed back is destroyed — so `as_input` sends kept items as `{id:}`
+    # and new containers as `{fileContainerId:}`.
+    # `items` is deliberately a plain doc reader, not `passarray`: materialising an ArrayModel
+    # writes `items: []` into the doc of a field read without $content, and a phantom-dirty
+    # empty `items` here doesn't no-op — it DELETES every attachment on the next update.
+    # Container ids come from a prior upload — see FileUpload::Client#upload_all.
     class FileField < DataField
-      passarray :fileContainers # each: { id:, fileName:, ... }
+      # each: { 'id' =>, 'fileContainer' => { 'id' =>, 'activeFileAttachment' => {...} } }
+      def items
+        Array(doc['items'])
+      end
 
       def file_container_ids
-        Array(fileContainers).map { |c| c.is_a?(Hash) ? c['id'] : c }.compact
+        items.map do |item|
+          item.is_a?(Hash) ? item.dig('fileContainer', 'id') : item
+        end.compact
       end
 
+      # Full-replace: containers already on the field keep their item identity;
+      # ids not present in `ids` are removed server-side by omission.
       def file_container_ids=(ids)
-        doc['fileContainers'] = Array(ids).map { |id_val| { 'id' => id_val } }
+        kept = {}
+        items.each do |item|
+          next unless item.is_a?(Hash) && (fc_id = item.dig('fileContainer', 'id'))
+
+          kept[fc_id] ||= item['id']
+        end
+        doc['items'] = Array(ids).map do |fc_id|
+          new_item = { 'fileContainer' => { 'id' => fc_id } }
+          new_item['id'] = kept[fc_id] if kept[fc_id]
+          new_item
+        end
       end
 
       def as_input
         return nil unless dirty?
 
-        { file: { id: id, fileContainerIds: file_container_ids } }
+        { file: { id: id, items: items_input } }
+      end
+
+      private
+
+      def items_input
+        items.map do |item|
+          next unless item.is_a?(Hash)
+
+          if (item_id = item['id'])
+            { id: item_id }
+          else
+            { fileContainerId: item.dig('fileContainer', 'id') }
+          end
+        end.compact
       end
     end
   end

data/lib/ecoportal/api/graphql/base/page/data_field/image_gallery.rb

@@ -1,8 +1,11 @@
 module Ecoportal::API::GraphQL::Base::Page
   class DataField
     # Image gallery field.
-    # Writing requires a prior file upload to the REST upload endpoint
-    # to obtain fileContainerIds — see the file-upload TODO in projects/TODO.md.
+    # ★ WRITE PATH BROKEN (schema-invalid, live-verified 2026-08): `ImageGalleryInput` has no
+    # `fileContainerIds` — it takes `images: [ImageInput]`, attaching via `sourceId`, which is
+    # an `Enzyme::ImageReference::TempImage` (a DIFFERENT upload pipeline than file containers).
+    # Fixing this needs its own design — see the DataField shape-asymmetry review project.
+    # The reader is equally stale: live responses carry `images`, not `fileContainers`.
     class ImageGallery < DataField
       passarray :fileContainers # each: { id:, fileName:, url:, ... }
 

data/lib/ecoportal/api/graphql/base/page/data_field/people.rb

@@ -4,20 +4,16 @@ module Ecoportal::API::GraphQL::Base::Page
       passarray :peopleIds
 
       def people_ids
-        ids = Array(peopleIds)
-        return ids unless ids.empty?
-
-        # Fallback: the read fragment populates `peopleIds`, but if a response ever returns it
-        # null/empty while the expanded `people { id }` nodes ARE present (a partial / non-
-        # $content read), seed from the nodes. The backend write replaces peopleIds wholesale,
-        # so a `people_ids << x` append must start from the existing set or it would WIPE the
-        # field. Mirrors CrossReference's references.nodes fallback. Read key == write key
-        # (peopleIds), so this only widens the read; it never creates phantom-dirty.
-        Array(doc['people']).map { |p| p.is_a?(Hash) ? p['id'] : p }.compact
+        people_ids_from(doc)
       end
 
       def people_ids=(ids)
-        doc['peopleIds'] = Array(ids).compact
+        # An explicit write makes `peopleIds` authoritative for THIS instance: without the
+        # flag, a deliberate clear (`people_ids = []`) on a `peopleIds: null` baseline would
+        # fall back to the `people` nodes on the doc side too, compare equal, and be silently
+        # dropped. The flag confines the fallback to un-written docs.
+        @people_ids_written  = true
+        doc['peopleIds']     = Array(ids).compact
       end
 
       # v2 compat: scripts may set via people_ids= or direct assignment
@@ -25,10 +21,52 @@ module Ecoportal::API::GraphQL::Base::Page
         self.people_ids = ids
       end
 
+      # Dirty only when the effective people-id SET actually changed.
+      #
+      # The read response can carry `peopleIds: null` while still populating the expanded
+      # `people { id }` (and `cachedPeople`) nodes (a partial / non-$content read). The
+      # default key-level leaf diff baselines on `original_doc['peopleIds']` (null), so
+      # writing the SAME id set as already attached looks like a brand-new key and flags
+      # a change — a phantom-dirty update that sends `peopleIds` for a no-op. Compare id
+      # SETS (falling back to `people[].id` on both sides) instead. Mirrors CrossReference's
+      # `references.nodes` fallback / `dirty?` override for the identical disease.
+      def dirty?
+        effective_people_ids.sort != people_ids_from(original_doc).sort
+      end
+
       def as_input
         return nil unless dirty?
 
-        { people: { id: id, peopleIds: Array(peopleIds) } }
+        { people: { id: id, peopleIds: effective_people_ids } }
+      end
+
+      private
+
+      # The id set the client currently means: after an explicit `people_ids=` write the raw
+      # `peopleIds` doc key is authoritative (so `[]` means CLEAR, no fallback); before any
+      # write it is the shape-agnostic read (fallback to `people[].id` nodes). Keeping
+      # `as_input` on the same source as `dirty?` also prevents an explicit clear from
+      # re-serialising fallback-seeded node ids.
+      def effective_people_ids
+        return Array(doc['peopleIds']).compact if @people_ids_written
+
+        people_ids_from(doc)
+      end
+
+      # Extract the people id set from a doc snapshot. `original_doc` is the server baseline
+      # (the diff prev_doc — see Diffable::ClassicDiffService), `doc` carries client changes.
+      # Prefer `peopleIds` when it is present and non-empty (the write shape, and the normal
+      # read shape); fall back to the expanded `people[].id` nodes (the read-only lookup
+      # shape) when `peopleIds` is absent/null/empty — so the comparison is shape-agnostic on
+      # both sides and stays correct after `consolidate!` copies `doc` into `original_doc`.
+      # `people` nodes are a lookup only, never written.
+      def people_ids_from(source_doc)
+        return [] unless source_doc
+
+        ids = Array(source_doc['peopleIds']).compact
+        return ids unless ids.empty?
+
+        Array(source_doc['people']).map { |p| p.is_a?(Hash) ? p['id'] : p }.compact
       end
     end
   end

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

@@ -10,24 +10,12 @@ module Ecoportal
             #
             # A DataField's array attributes (`options`, `peopleIds`, `contractors`,
             # `pages`, `fileContainers`, `items`, ...) are declared with `passarray`,
-            # which registers them as *cascaded* attributes. The default `DiffService`
-            # strips cascaded keys from the flat classic diff (`doc_with_non_cascaded_attributes`)
-            # on the assumption that a later `diff_reduce` pass re-adds them by cascading
-            # into nested `GraphQL::Model` children. DataField arrays are plain hashes /
-            # strings, not `GraphQL::Model` objects, so that re-add never happens and the
-            # array change becomes invisible to the diff (scalar `passthrough` fields are
-            # unaffected). For a leaf model we want every doc key diffed inline, so this
-            # service keeps cascaded keys in place.
-            class LeafDiffService < Ecoportal::API::Common::GraphQL::Model::Diffable::DiffService
-              private
-
-              # Keep all doc keys: leaf-field arrays are data, not nested models.
-              def doc_with_non_cascaded_attributes(json)
-                json
-              end
-            end
-
-            DIFF_CLASS = LeafDiffService
+            # which registers them as *cascaded* attributes invisible to the default
+            # `DiffService` (see `Diffable::LeafDiffService` for the full explanation).
+            # A DataField is a pure leaf model (no nested `GraphQL::Model` children), so
+            # it diffs `flat: true` — the promoted shared `LeafDiffService` keeps the
+            # array doc keys inline.
+            DIFF_CLASS = Ecoportal::API::Common::GraphQL::Model::Diffable::LeafDiffService
             # Map GraphQL __typename values to subclass names.
             TYPE_MAP = {
               'PlainText'          => 'PlainText',
@@ -55,6 +43,12 @@ module Ecoportal
 
             passkey :id
             passthrough :label, :deindex, :genomeSignature
+            # `read_only: true` is load-bearing, not documentation: `description` is readable on
+            # `DataFieldsInterface` but ABSENT from `DataFieldInput` and every per-type member of
+            # it, so a writable accessor would make the field dirty and push a key `updatePage`
+            # cannot accept. The only writer is the `editFieldConfiguration` workflow command
+            # (`Input::WorkflowCommand::EditFieldConfiguration`).
+            passthrough :description, read_only: true
             # __typename is stored under the 'type' key after mapping
             passthrough :type
 

data/lib/ecoportal/api/graphql/base/page/phased/stage.rb

@@ -10,6 +10,9 @@ module Ecoportal
               passkey :id
               passthrough :name, :ordering, :state
               passboolean :active, :started
+              # Per-stage tag set (Stage.tags in the schema). Fetched by the stageAttrs
+              # fragment; a component of #all_tags. Empty array when not queried.
+              passarray :tags
 
               class_resolver :callback_type_class, 'Ecoportal::API::GraphQL::Base::PagesWorkflow::CallbackType'
 
@@ -17,6 +20,54 @@ module Ecoportal
               # canonical field objects (filtered to this stage) rather than fresh dups.
               attr_writer :page_field_collection
 
+              # The owning page, resolved via the DoubleModel's NATIVE nesting reference rather
+              # than a manually-injected back-ref. A stage is embedded under the page as
+              # page -> stages (CollectionModel) -> stage, so `_parent` is the intermediate
+              # collection, NOT the page. `root` walks the whole `_parent` chain to the top of
+              # the doc model (the page), which is robust to that intermediate nesting.
+              #
+              # Returns the page for an embedded stage, or nil for a standalone stage whose root
+              # is itself (i.e. not a page — has no baseTags/otherTags/location_ids to fold in).
+              def page
+                top = root
+                top.equal?(self) ? nil : top
+              end
+
+              # location_ids redirect: the GraphQL Stage type has NO location field — locations
+              # are assigned at the PAGE level (page.locations { id }). So a stage's location ids
+              # are the page's location ids. Empty array for a standalone stage.
+              def location_ids
+                Array(page&.location_ids)
+              end
+
+              # The stage's fully-compiled tag set (client-side build of the backend-only
+              # "compiled_tags"), per the domain formula:
+              #
+              #   Stage.all_tags = page.baseTags + page.location_ids + page.otherTags + stage.tags
+              #
+              # (page.location_ids — surfaced here via #location_ids — stands in for the per-stage
+              #  "location_ids" of the formula: the GraphQL schema does NOT expose locations on the
+              #  Stage type, they are assigned at the PAGE level.)
+              #
+              # Returns a de-duplicated Array of tag strings. For a standalone stage (no owning
+              # page) folds in only the stage's own tags.
+              def all_tags
+                (page_base_tags + location_ids + page_other_tags + Array(tags)).
+                  compact.uniq
+              end
+
+              private
+
+              def page_base_tags
+                page ? Array(page.baseTags) : []
+              end
+
+              def page_other_tags
+                page ? Array(page.otherTags) : []
+              end
+
+              public
+
               def workflow_callbacks
                 @workflow_callbacks ||= Array(doc['workflowCallbacks'] || []).map { |cb| callback_type_class.from_doc(cb) }
               end

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

@@ -0,0 +1,15 @@
+module Ecoportal
+  module API
+    class GraphQL
+      module Base
+        # Permissions ? the org-level ability set (Organization.permissions).
+        # Every field is a `canXXX: AuthorizationResult!` permission check. Read-only.
+        # The concrete embeds_one declarations live on Model::Permissions (they reference
+        # Model::AuthorizationResult).
+        class Permissions < Logic::BaseModel
+          read_only!
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,23 @@
+module Ecoportal
+  module API
+    class GraphQL
+      module Base
+        # A single audit entry in a person member's changelog history, returned by
+        # `PersonMember.changelogs` / `Organization.personMemberChangelogs`. Read-only.
+        #
+        # Enum-valued fields are exposed as plain strings:
+        # - operation / accountOperation: 'CREATE' | 'UPDATE' | 'DESTROY'
+        class PersonMemberChangelog < Logic::BaseModel
+          read_only!
+
+          passkey :id
+          passthrough :operation, :accountOperation
+          passthrough :personMemberId, :apiKeyPrefix
+          passboolean :changedByApi
+          passarray :humanReadableDifferences
+          embeds_one :createdAt, klass: Base::DateTime
+        end
+      end
+    end
+  end
+end

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

@@ -5,11 +5,146 @@ module Ecoportal
         # 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 @@ module Ecoportal
     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/template/change_log_entry.rb

@@ -0,0 +1,118 @@
+module Ecoportal
+  module API
+    class GraphQL
+      module Base
+        module Template
+          # One entry of a TEMPLATE's change log — a single command the platform recorded
+          # against the template. Read-only.
+          #
+          # ── Where it comes from (verified in the Rails backend on 2026-08-19) ────────────
+          # `app/graphql/types/pages/template_type.rb` declares
+          #   field :commands, Types::Pages::Interfaces::WorkflowCommandInterface.connection_type
+          # and resolves it as
+          #   NewEp::Pages::Workflows::Commands::Base.where(page: object.page)
+          #                                          .from_template_builder.order(_id: :desc)
+          #
+          # The narrow `Template` type itself is reachable as `template { ... }` on any page,
+          # because `app/graphql/types/pages/interfaces/base_page_interface.rb:27` declares
+          #   field :template, Types::Pages::TemplateType, null: true
+          #
+          # ── ★ TWO ACCESS CAVEATS — both are silent, neither raises ─────────────────────
+          # 1. `commands` returns **nil**, not an empty connection, unless the caller satisfies
+          #    `Pages::TemplatePolicy#update_information?` (`return unless allowed_to?(...)`).
+          #    A read-only account therefore sees NO change log and gets no error saying so.
+          #    Treat a nil connection as "not permitted", never as "nothing changed".
+          # 2. The scope is `.from_template_builder` — only `TEMPLATE_BUILDER`-sourced commands
+          #    appear. `WORKFLOW_BUILDER` commands against the same page are EXCLUDED
+          #    (`app/models/new_ep/pages/workflows/commands/base.rb`, `enum_field :feature_source`
+          #    with values WORKFLOW_BUILDER / TEMPLATE_BUILDER). For the workflow-builder side of
+          #    the same log see `Query::PagesWorkflowCommands`.
+          # Ordering is `_id: :desc` — newest first, server-side, not configurable.
+          #
+          # ── ★ WHY THIS LOG BEATS POLLING A WATERMARK ──────────────────────────────────
+          # `app/services/new_ep/pages/run_merged_forces.rb:17` writes with
+          #   @page.timeless.skip_patch_incr.rewrite(only_if: { updated_at: @page.updated_at.utc })
+          # so a forces run bumps NEITHER `patchVer` NOR `updatedAt`. Any change tracker that
+          # polls a watermark is structurally blind to force-driven change; the command log is
+          # per-change and cannot be skipped that way.
+          # (OPEN: whether forces run against TEMPLATES specifically is NOT confirmed — do not
+          # assume either way.)
+          #
+          # ── Field set ─────────────────────────────────────────────────────────────────
+          # These are the fields of the INTERFACE `PagesWorkflowCommandInterface` only
+          # (`app/graphql/types/pages/interfaces/workflow_command_interface.rb`). The concrete
+          # implementing types add their own (`PagesWorkflowCommandChange.changes`,
+          # `PagesWorkflowCommandChangeMessage.changeMessages`,
+          # `PagesWorkflowCommandEsChange.changes`); `__typename` is passed through so a caller
+          # can branch, and those extras can be selected with an inline fragment or by reusing
+          # `Fragment :PagesWorkflowCommandFields`.
+          #
+          # Enum-valued fields are exposed as plain strings:
+          # - commandAction: WorkflowCommandActionEnum
+          class ChangeLogEntry < Logic::BaseModel
+            read_only!
+
+            passkey :id
+            # Concrete type name: 'PagesWorkflowCommandChange' | 'PagesWorkflowCommandChangeMessage'
+            # | 'PagesWorkflowCommandEsChange'.
+            passthrough :__typename
+            passthrough :commandAction
+            # Optimistic-concurrency token the command was recorded against (Int!).
+            passthrough :patchVer
+            # `owner` (the UserType embed) is added in Model::Template::ChangeLogEntry — Base
+            # loads before Model.
+            passthrough :ownerId
+            passthrough :stageId, :stageName
+            passthrough :taskId, :taskType
+            # What the command acted on. Resolved server-side from `targeted_resource` and
+            # nil for commands that target nothing.
+            passthrough :targetedResourceId, :targetedResourceName, :targetedResourceType
+
+            # `createdAt`/`updatedAt` are `DateTimeType` OBJECTS ({ dateTime, timeZone }), not
+            # scalars — hence an embed rather than `passdate`. Use `entry.createdAt.dateTime`.
+            embeds_one :createdAt, klass: Base::DateTime
+            embeds_one :updatedAt, klass: Base::DateTime
+
+            # ── What actually changed (only populated by the DETAIL selection) ──────────
+            # Present only when the node was selected with `Fragment :TemplateChangeLogEntryDetail`
+            # (see `Query::TemplateChangeLog.detail_block` / `api.template.change_log(detail: true)`).
+            # With the default light selection both readers are empty — empty means
+            # "not selected", NOT "nothing changed", exactly like the nil-connection caveat above.
+            #
+            # Deliberately raw hashes rather than a typed embed: the two `changes`-bearing types
+            # do not share a shape (`ChangeType.from/to` are Strings;
+            # `StoredEsFilterChangeType.from/to` are objects), so one typed model would have to
+            # lie about one of them. This mirrors `Base::PagesWorkflow::CommandChange#changes`,
+            # which does the same for the workflow-builder side of the same interface.
+            def changes
+              Array(doc['changes'])
+            end
+
+            passarray :changeMessages
+
+            # Which of the three concrete command types this entry is, as a symbol:
+            # :changes | :change_messages | :es_changes | nil (unknown/unselected `__typename`).
+            # Use it instead of string-matching `__typename` at call sites.
+            DETAIL_KINDS = {
+              'PagesWorkflowCommandChange'        => :changes,
+              'PagesWorkflowCommandChangeMessage' => :change_messages,
+              'PagesWorkflowCommandEsChange'      => :es_changes
+            }.freeze
+
+            def detail_kind
+              DETAIL_KINDS[__typename]
+            end
+
+            # True when this entry carries field-level detail. False both when the light
+            # selection was used and when a command genuinely recorded no changes -- those two
+            # are indistinguishable from the response alone, which is why the caller should know
+            # which selection it asked for.
+            def detail?
+              !changes.empty? || !changeMessages.to_a.empty?
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -28,6 +28,8 @@ module Ecoportal
             passthrough :title, :registerId
             passboolean :hasInaccessibleVariables
           end
+
+          require_relative 'template/change_log_entry'
         end
       end
     end

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