ecoportal-api-graphql 2.0.0 → 3.0.0

data/lib/ecoportal/api/graphql/model/page/phased.rb

@@ -24,6 +24,8 @@ module Ecoportal
               embedded = super
               # Share the page's canonical field objects with each stage, so mutations made
               # via stage.components reach the page's data_fields_updates (phased write-path).
+              # NOTE: no manual `page` back-ref injection — Stage#page resolves the owning page
+              # via the DoubleModel's native `root` reference (page -> stages collection -> stage).
               fc = field_collection
               Array(embedded).each do |st|
                 st.page_field_collection = fc if st.respond_to?(:page_field_collection=)
@@ -31,6 +33,21 @@ module Ecoportal
               Compat::StageCollection.new(embedded)
             end
 
+            # Page-level compiled tag set (client-side build of the backend-only
+            # "compiled_tags"), per the domain formula:
+            #
+            #   Page.all_tags = Unique(⋃ all stages' all_tags)
+            #
+            # De-duplicated Array of tag strings across every stage. A phased page with no
+            # stages falls back to the page-level components (baseTags + otherTags +
+            # location_ids), matching the basic-page behaviour on Interface::BasePage.
+            def all_tags
+              stgs = Array(stages)
+              return super if stgs.empty?
+
+              stgs.flat_map(&:all_tags).compact.uniq
+            end
+
             # v2 compatible: ID of the stage with state == 'inprogress', or nil
             def current_stage_id
               raw = doc['stagesIndex'] || doc['stages']

data/lib/ecoportal/api/graphql/model/page/section.rb

@@ -1,12 +1,12 @@
-module Ecoportal
-  module API
-    class GraphQL
-      module Model
-        module Page
-          class Section < Base::Page::Section
-          end
-        end
-      end
-    end
-  end
-end
+module Ecoportal
+  module API
+    class GraphQL
+      module Model
+        module Page
+          class Section < Base::Page::Section
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -1,21 +1,21 @@
-module Ecoportal
-  module API
-    class GraphQL
-      module Model
-        # Factory class — dispatches on __typename to the correct concrete page class.
-        # Must be a Class (not a Module): v2's resolve_class matches `when Class`, so a
-        # Module target falls through to "Unknown class". `self.new` is overridden to
-        # return the concrete page instance instead of a PageUnion instance.
-        class PageUnion
-          def self.new(doc, **opts)
-            case doc&.fetch('__typename', nil)
-            when 'BasicPage'  then Page::Basic.new(doc, **opts)
-            when 'PhasedPage' then Page::Phased.new(doc, **opts)
-            else                   Interface::BasePage.new(doc, **opts)
-            end
-          end
-        end
-      end
-    end
-  end
-end
+module Ecoportal
+  module API
+    class GraphQL
+      module Model
+        # Factory class — dispatches on __typename to the correct concrete page class.
+        # Must be a Class (not a Module): v2's resolve_class matches `when Class`, so a
+        # Module target falls through to "Unknown class". `self.new` is overridden to
+        # return the concrete page instance instead of a PageUnion instance.
+        class PageUnion
+          def self.new(doc, **opts)
+            case doc&.fetch('__typename', nil)
+            when 'BasicPage'  then Page::Basic.new(doc, **opts)
+            when 'PhasedPage' then Page::Phased.new(doc, **opts)
+            else                   Interface::BasePage.new(doc, **opts)
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -1,20 +1,20 @@
-module Ecoportal
-  module API
-    class GraphQL
-      module Model
-        class PagesWorkflow < Base::PagesWorkflow
-          SCHEMA_VERSION = '20260605'.freeze
-
-          class_resolver :command_connection_class,
-                         'Ecoportal::API::GraphQL::Connection::PagesWorkflowCommand'
-
-          class_resolver :operation_class,
-                         'Ecoportal::API::GraphQL::Base::PagesWorkflow::OperationUnion'
-
-          class_resolver :trigger_class,
-                         'Ecoportal::API::GraphQL::Base::PagesWorkflow::TriggerUnion'
-        end
-      end
-    end
-  end
-end
+module Ecoportal
+  module API
+    class GraphQL
+      module Model
+        class PagesWorkflow < Base::PagesWorkflow
+          SCHEMA_VERSION = '20260605'.freeze
+
+          class_resolver :command_connection_class,
+                         'Ecoportal::API::GraphQL::Connection::PagesWorkflowCommand'
+
+          class_resolver :operation_class,
+                         'Ecoportal::API::GraphQL::Base::PagesWorkflow::OperationUnion'
+
+          class_resolver :trigger_class,
+                         'Ecoportal::API::GraphQL::Base::PagesWorkflow::TriggerUnion'
+        end
+      end
+    end
+  end
+end

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

@@ -108,6 +108,9 @@ module Ecoportal
                      klass: "Ecoportal::API::GraphQL::Model::AuthorizationResult", nullable: true
           embeds_one :pageCanUseDrafts,
                      klass: "Ecoportal::API::GraphQL::Model::AuthorizationResult", nullable: true
+          # DEPRECATED (20260929): removed from the live schema by the smart-assistant
+          # consolidation; no longer selected by Fragment::Permissions, so always nil. Kept so
+          # callers get nil instead of NoMethodError.
           embeds_one :pageSmartAssistantCanChat,
                      klass: "Ecoportal::API::GraphQL::Model::AuthorizationResult", nullable: true
           embeds_one :personSchemaCanAccessManager,
@@ -120,6 +123,9 @@ module Ecoportal
                      klass: "Ecoportal::API::GraphQL::Model::AuthorizationResult", nullable: true
           embeds_one :publicTemplatesCanManage,
                      klass: "Ecoportal::API::GraphQL::Model::AuthorizationResult", nullable: true
+          # DEPRECATED (20260929): removed from the live schema by the smart-assistant
+          # consolidation; no longer selected by Fragment::Permissions, so always nil. Kept so
+          # callers get nil instead of NoMethodError.
           embeds_one :registerAssistantCanChat,
                      klass: "Ecoportal::API::GraphQL::Model::AuthorizationResult", nullable: true
           embeds_one :registerCanAccessRegisterTools,

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

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

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

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

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

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

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

@@ -1,13 +1,13 @@
-module Ecoportal
-  module API
-    class GraphQL
-      module Model
-        class Resource < Base::Resource
-          embeds_one :page, klass: 'Ecoportal::API::GraphQL::Model::Page::Phased', read_only: true # PageUnion
-          embeds_one :field, klass: 'Ecoportal::API::GraphQL::Model::Field', read_only: true
-          # embeds_many :stages, klass: 'Ecoportal::API::GraphQL::Model::SimpleStage'
-        end
-      end
-    end
-  end
-end
+module Ecoportal
+  module API
+    class GraphQL
+      module Model
+        class Resource < Base::Resource
+          embeds_one :page, klass: 'Ecoportal::API::GraphQL::Model::Page::Phased', read_only: true # PageUnion
+          embeds_one :field, klass: 'Ecoportal::API::GraphQL::Model::Field', read_only: true
+          # embeds_many :stages, klass: 'Ecoportal::API::GraphQL::Model::SimpleStage'
+        end
+      end
+    end
+  end
+end

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

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

data/lib/ecoportal/api/graphql/model/template/binding.rb

@@ -0,0 +1,60 @@
+module Ecoportal
+  module API
+    class GraphQL
+      module Model
+        module Template
+          # A force binding — `addBinding`/`editBinding`'s `referenceId` is the field (or field
+          # placeholder) the binding points at. `reference_id=` accepts either a raw id/String
+          # OR a `Field` (or any object answering `#ref`) so a caller can write
+          # `binding.reference_id = some_field` and let the SAME just-created-or-real-id
+          # resolution `Field#ref` already does apply here automatically — no separate
+          # "resolve the field id" step for the caller to remember.
+          class Binding
+            include Node
+
+            PLACEHOLDER_PREFIX = 'bnd'.freeze
+
+            BINDING_TYPE = 'field'.freeze
+
+            attr_reader :template, :force, :type
+            attr_accessor :name
+
+            def initialize(template:, force:, id: nil, name: nil, reference_id: nil, type: BINDING_TYPE)
+              @template     = template
+              @force        = force
+              @id           = id
+              @name         = name
+              @type         = type
+              self.reference_id = reference_id
+              @snapshot = snapshot_attrs.freeze
+            end
+
+            attr_writer :reference_id
+
+            # Resolved at read time: the referenced node's own `#ref` when it is one (a `Field`
+            # or anything else in this tree), otherwise the raw value as given.
+            def reference_id
+              @reference_id.respond_to?(:ref) ? @reference_id.ref : @reference_id
+            end
+
+            def dirty?
+              !removed? && !new? && snapshot_attrs != @snapshot
+            end
+
+            def changed_attributes
+              return {} if new? || removed?
+
+              snapshot_attrs.each_with_object({}) { |(k, v), h| h[k] = v if v != @snapshot[k] }
+            end
+
+            private
+
+            def snapshot_attrs
+              { name: name, reference_id: reference_id }
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ecoportal/api/graphql/model/template/change_log_entry.rb

@@ -0,0 +1,19 @@
+module Ecoportal
+  module API
+    class GraphQL
+      module Model
+        module Template
+          # Concrete read model for one entry of a template's change log. Adds the relational
+          # embed on top of the interface fields modelled in `Base::Template::ChangeLogEntry`
+          # (which is where the platform caveats are documented — read them before using this).
+          class ChangeLogEntry < Base::Template::ChangeLogEntry
+            # `owner` is a `UserType` (id / name / email) — WHO made the change. Resolved
+            # server-side from `owner_id` via RecordLoader, so it is nil for system-originated
+            # commands with no user. Prefer `owner&.name` over `ownerId` for reporting.
+            embeds_one :owner, klass: Model::User, nullable: true
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ecoportal/api/graphql/model/template/command_grouper.rb

@@ -0,0 +1,107 @@
+module Ecoportal
+  module API
+    class GraphQL
+      module Model
+        module Template
+          # Groups an ordered command batch into chunks no larger than `chunk_size`, never
+          # splitting a placeholder-minting command away from any OTHER command in the SAME
+          # batch that references that placeholder (a `placeholderId` is only valid within the
+          # ONE `executeWorkflowCommands`/`updatePageTemplate` call that mints it —
+          # `18_template_editor_save_path.md` section B.1). Connected components (union-find
+          # over "which commands share a placeholder token") are packed into chunks in
+          # first-appearance order, so a chunk boundary only ever falls BETWEEN independent
+          # groups, never inside one.
+          module CommandGrouper
+            PLACEHOLDER_RE = /\Aph_/
+
+            class << self
+              # @param commands [Array<Hash>] built command hashes (`{ commandKey => input }`).
+              # @param chunk_size [Integer]
+              # @return [Array<Array<Hash>>] ordered chunks.
+              def chunk(commands, chunk_size)
+                slice_groups(group(commands), chunk_size)
+              end
+
+              # Every `ph_...` token referenced ANYWHERE in `commands` (minted or referenced).
+              # Public: `StagedExecutor`'s stale-placeholder guard uses this directly.
+              def tokens_in(commands)
+                commands.flat_map { |c| placeholder_tokens(c) }.uniq
+              end
+
+              private
+
+              def group(commands)
+                parent = {}
+                find = find_proc(parent)
+                token_owner = {}
+
+                commands.each_index do |i|
+                  find.call(i)
+                  placeholder_tokens(commands[i]).each do |tok|
+                    token_owner.key?(tok) ? union(parent, find, i, token_owner[tok]) : (token_owner[tok] = i)
+                  end
+                end
+
+                buckets = Hash.new { |h, k| h[k] = [] }
+                commands.each_index { |i| buckets[find.call(i)] << commands[i] }
+                buckets.values
+              end
+
+              def find_proc(parent)
+                find = nil
+                find = lambda do |x|
+                  parent[x] ||= x
+                  parent[x] = find.call(parent[x]) unless parent[x] == x
+                  parent[x]
+                end
+              end
+
+              def union(parent, find, idx_a, idx_b)
+                root_a = find.call(idx_a)
+                root_b = find.call(idx_b)
+                parent[root_a] = root_b unless root_a == root_b
+              end
+
+              def slice_groups(groups, chunk_size)
+                chunks  = []
+                current = []
+                groups.each do |members|
+                  guard_group_size!(members, chunk_size)
+                  if current.size + members.size > chunk_size
+                    chunks << current
+                    current = []
+                  end
+                  current.concat(members)
+                end
+                chunks << current unless current.empty?
+                chunks
+              end
+
+              def guard_group_size!(members, chunk_size)
+                return if members.size <= chunk_size
+
+                tally = members.map { |c| c.keys.first }.tally
+                raise "CommandGrouper: a placeholder-connected group of #{members.size} commands " \
+                      "exceeds chunk_size (#{chunk_size}) and cannot be split without breaking a " \
+                      "same-batch placeholder reference. Key tally: #{tally}"
+              end
+
+              def placeholder_tokens(command)
+                command.values.flat_map { |v| scan(v) }
+              end
+
+              def scan(value)
+                case value
+                when String then PLACEHOLDER_RE.match?(value) ? [value] : []
+                when Hash   then value.values.flat_map { |v| scan(v) }
+                when Array  then value.flat_map { |v| scan(v) }
+                else []
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ecoportal/api/graphql/model/template/command_normalizer.rb

@@ -0,0 +1,116 @@
+module Ecoportal
+  module API
+    class GraphQL
+      module Model
+        module Template
+          # Normalises an ordered batch of built `WorkflowCommand` hashes
+          # (`[{ commandKey => { ...input } }, ...]`) so that batches produced by DIFFERENT
+          # emitters -- each of which mints its own placeholder/id tokens (`Builder::
+          # TemplateBuilder`'s `ph_stg_1`, `Diff::CommandSynthesizer`'s `ph_stg_0`,
+          # `CommandSynthesis`'s `ph_stg_1`, a self-version replay's real server ids, the downstream
+          # writers' caller-chosen tokens) -- can be compared for STRUCTURAL equivalence.
+          #
+          # Two normalisations, both pure (no mutation of the input):
+          #
+          #   1. REFERENCE-TOKEN POSITIONING. Every value carried under a key this class
+          #      recognises as an id/placeholder REFERENCE (see `REFERENCE_KEYS`) is replaced
+          #      by a positional token `"ph_<n>"`, assigned in FIRST-APPEARANCE order across
+          #      the whole ordered batch (scanning left to right, top to bottom, depth-first
+          #      within each command's own Hash). The SAME source value always maps to the
+          #      SAME token wherever it recurs (so a mint-then-reference pair, e.g. `addStage`'s
+          #      `placeholderId` and a later `addStageSection`'s `stageId`, stays linked). Only
+          #      the KEY decides whether a String is a reference -- literal content
+          #      (`label`/`name`/`value`/`script`/`url`/...) is never touched, so a coincidental
+          #      value match with a real id never causes a false substitution.
+          #   2. KEY ORDER + correlation stripping. Each command's own input Hash (and any
+          #      nested Hash, e.g. `byType`) is recursively re-sorted by key so two batches that
+          #      differ only in the Hash literal's construction order compare equal, and any
+          #      `CORRELATION_KEYS` entry (never part of the compared shape) is dropped.
+          #
+          # Two normalised batches are STRUCTURALLY EQUIVALENT iff `Normalizer.normalize(a) ==
+          # Normalizer.normalize(b)` -- byte-identical once serialised (`to_json`), per the
+          # DSL-08 acceptance test.
+          class CommandNormalizer
+            # Keys whose String value addresses a node (mint or reference), across every
+            # `WorkflowCommand` input class this repo ships plus the downstream writers' own commands
+            # (`placeholderId`/`stageId`/`sectionId`/`dataFieldId`/`data_field_id`/`optionId`/
+            # `forceId`/`referenceId`/`anchorId`/`id`) -- verified against every `VALID_KEYS`
+            # list under `lib/ecoportal/api/graphql/input/workflow_command/`. Deliberately a
+            # CLOSED, named set (not "every String") so a literal content String (a label, a
+            # script, a URL) is never mistaken for a reference.
+            REFERENCE_KEYS = %i[
+              placeholderId stageId sectionId dataFieldId data_field_id optionId
+              forceId referenceId anchorId id
+            ].freeze
+
+            # Fields that exist only for request bookkeeping, never part of the compared shape.
+            CORRELATION_KEYS = %i[clientMutationId correlationId].freeze
+
+            # @param commands [Array<Hash>] an ordered batch, each a single-key Hash
+            #   (`{ commandKey => { ...input } }`).
+            # @return [Array<Hash>] the same batch, reference tokens repositioned, keys sorted,
+            #   correlation-only keys dropped. Deterministic and comparable with `==`.
+            def self.normalize(commands)
+              new.normalize(commands)
+            end
+
+            def normalize(commands)
+              @tokens     = {}
+              @next_index = 0
+              Array(commands).map { |command| normalize_command(command) }
+            end
+
+            private
+
+            def normalize_command(command)
+              command_key = command.keys.first
+              body        = command[command_key]
+              { command_key => deep_sort(normalize_hash(body)) }
+            end
+
+            def normalize_hash(hash)
+              hash.each_with_object({}) do |(key, value), out|
+                next if CORRELATION_KEYS.include?(key.to_sym)
+
+                out[key] = normalize_value(key, value)
+              end
+            end
+
+            def normalize_value(key, value)
+              case value
+              when Hash  then normalize_hash(value)
+              when Array then value.map { |element| normalize_value(key, element) }
+              when String then reference_key?(key) ? token_for(value) : value
+              else value
+              end
+            end
+
+            def reference_key?(key)
+              REFERENCE_KEYS.include?(key.to_sym)
+            end
+
+            # The SAME source value (whatever token/id format the emitter minted) always maps
+            # to the SAME positional token -- first appearance decides the number.
+            def token_for(raw_value)
+              @tokens[raw_value] ||= begin
+                @next_index += 1
+                "ph_#{@next_index}"
+              end
+            end
+
+            # Recursively re-sorts every Hash (top-level input and any nested sub-hash, e.g.
+            # `byType`) by key, so construction-order differences never cause a false mismatch.
+            # Arrays keep their own order (option/command ORDER is part of what is compared).
+            def deep_sort(value)
+              case value
+              when Hash  then value.map { |k, v| [k, deep_sort(v)] }.sort_by { |(k, _)| k.to_s }.to_h
+              when Array then value.map { |element| deep_sort(element) }
+              else value
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end