ecoportal-api-graphql 1.3.17 → 2.0.0

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/preview_page.rb

@@ -1,23 +1,23 @@
-module Ecoportal
-  module API
-    class GraphQL
-      module Base
-        # Elasticsearch-backed preview of a page, returned by register.previewPages.
-        # Read-only. No patchVer, no typed data field models, no field IDs.
-        # Use for fast metadata lookup only — switch to org search (pages) for full data.
-        class PreviewPage < Logic::BaseModel
-          read_only!
-
-          passkey :id
-          passthrough :uid, :name, :state, :archived
-          passthrough :creatorName, :externalId
-          passdate :createdAt, :updatedAt
-
-          # locations, dataFields, stages returned as raw arrays — typed access not needed
-          # for a read-only ES-backed preview model. Use org search for typed field access.
-          passarray :locations, :dataFields, :stages, :tags
-        end
-      end
-    end
-  end
-end
+module Ecoportal
+  module API
+    class GraphQL
+      module Base
+        # Elasticsearch-backed preview of a page, returned by register.previewPages.
+        # Read-only. No patchVer, no typed data field models, no field IDs.
+        # Use for fast metadata lookup only — switch to org search (pages) for full data.
+        class PreviewPage < Logic::BaseModel
+          read_only!
+
+          passkey :id
+          passthrough :uid, :name, :state, :archived
+          passthrough :creatorName, :externalId
+          passdate :createdAt, :updatedAt
+
+          # locations, dataFields, stages returned as raw arrays — typed access not needed
+          # for a read-only ES-backed preview model. Use org search for typed field access.
+          passarray :locations, :dataFields, :stages, :tags
+        end
+      end
+    end
+  end
+end

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

@@ -1,8 +1,13 @@
-module Ecoportal
+module Ecoportal
   module API
     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/resource.rb

@@ -1,13 +1,13 @@
-module Ecoportal
-  module API
-    class GraphQL
-      module Base
-        class Resource < Logic::BaseModel
-          passkey :id
-          passthrough :fieldId, :pageId
-          passarray :stageIds
-        end
-      end
-    end
-  end
-end
+module Ecoportal
+  module API
+    class GraphQL
+      module Base
+        class Resource < Logic::BaseModel
+          passkey :id
+          passthrough :fieldId, :pageId
+          passarray :stageIds
+        end
+      end
+    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/CLAUDE.md

@@ -0,0 +1,65 @@
+# builder
+
+Façade classes that group related mutations (and occasional queries) under a single object.
+Consumers interact with builders rather than instantiating `Logic::Mutation` / `Logic::Query`
+subclasses directly.
+
+## Contents
+
+| File / class | Exposed from `GraphQL` as | Purpose |
+|---|---|---|
+| `action.rb` / `Builder::Action` | `GraphQL#action` | `create`, `update`, `archive` — wraps `Mutation::Action::*` |
+| `contractor_entity.rb` / `Builder::ContractorEntity` | `GraphQL#contractorEntity` | `create`, `update`, `destroy` — wraps `Mutation::ContractorEntity::*` |
+| `location_structure.rb` / `Builder::LocationStructure` | `GraphQL#locationStructure` | `nodeClassifications` (query), `applyCommandsInput`, `applyCommands`, `draft` sub-builder |
+| `location_structure/draft.rb` / `Builder::LocationStructure::Draft` | via `locationStructure.draft` | Location structure draft mutations |
+| `page.rb` / `Builder::Page` | `GraphQL#page` | Full page lifecycle: `update`, `archive`, `unarchive`, `build_from_template`, `create_from_template`, `create_draft`, `delete_draft`, `publish_draft`, `approve/reject/restart/undo/batch_update_review_task`, `execute_workflow_commands` (new), `execute_force_commands` (deprecated) |
+| `register.rb` / `Builder::Register` | *(not yet exposed)* | **Stub** — all methods commented out. No `Mutation::Register::*` classes exist yet. See TODO below. |
+
+## How builders are exposed
+
+All active builders are wired in `lib/ecoportal/api/graphql.rb` as instance methods:
+
+```ruby
+def page
+  Builder::Page.new(client)
+end
+def action
+  Builder::Action.new(client)
+end
+# etc.
+```
+
+`registers` (note: plural, lowercase) returns `Compat::Registers`, **not** `Builder::Register`.
+`Builder::Register` is a stub and is not yet wired into the top-level class.
+
+## Builder::Register — TODO
+
+`builder/register.rb` contains a stub class with all methods commented out.
+Before it can be implemented:
+
+1. Research which Register mutations exist in the schema (`createRegister`,
+   `updateRegister`, `archiveRegister`, etc.) — none are currently documented
+   in `.ai-assistance/code/ecoportal_schema_reference.md`.
+2. Create `Mutation::Register::*` + `Input::Register::*` + `Payload::Register::*`
+   following the pattern of `Mutation::Page::*`.
+3. Expose `Builder::Register` from `GraphQL#register` (distinct from `#registers`
+   which is the compat search layer).
+
+Until then, register mutation callers must instantiate `Mutation::Register::*` directly
+(none exist yet), or use `Compat::Registers` for search.
+
+## Conventions
+
+- One builder per domain entity. Sub-builders (e.g. `LocationStructure::Draft`) are
+  nested under their parent builder's folder and exposed via a method on the parent.
+- Builder methods are snake_case public API; private helper methods are camelCase
+  (matching the existing convention: `updateMutation`, `archiveMutation`, etc.).
+- Builders never hold state — each method instantiates a fresh mutation/query object.
+- Builders do not implement pagination; callers use `QueryConnection#each` for that.
+
+## Related
+
+- `../mutation/` — concrete mutation classes that builders delegate to
+- `../query/` — concrete query classes (some builders also expose query shortcuts)
+- `../compat/` — v2-compatible layer (`Compat::Pages`, `Compat::Registers`) that
+  wraps builders + queries with an eco-helpers-compatible interface

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

@@ -1,41 +1,41 @@
-module Ecoportal
-  module API
-    class GraphQL
-      module Builder
-        class Action
-          attr_reader :client
-
-          def initialize(client)
-            @client = client
-          end
-
-          def archive(**kargs, &block)
-            archiveMutation.query(**kargs, &block)
-          end
-
-          def update(**kargs, &block)
-            updateMutation.query(**kargs, &block)
-          end
-
-          def create(**kargs, &block)
-            createMutation.query(**kargs, &block)
-          end
-
-          private
-
-          def archiveMutation
-            Mutation::Action::Archive.new(client)
-          end
-
-          def updateMutation
-            Mutation::Action::Update.new(client)
-          end
-
-          def createMutation
-            Mutation::Action::Create.new(client)
-          end
-        end
-      end
-    end
-  end
-end
+module Ecoportal
+  module API
+    class GraphQL
+      module Builder
+        class Action
+          attr_reader :client
+
+          def initialize(client)
+            @client = client
+          end
+
+          def archive(**kargs, &block)
+            archiveMutation.query(**kargs, &block)
+          end
+
+          def update(**kargs, &block)
+            updateMutation.query(**kargs, &block)
+          end
+
+          def create(**kargs, &block)
+            createMutation.query(**kargs, &block)
+          end
+
+          private
+
+          def archiveMutation
+            Mutation::Action::Archive.new(client)
+          end
+
+          def updateMutation
+            Mutation::Action::Update.new(client)
+          end
+
+          def createMutation
+            Mutation::Action::Create.new(client)
+          end
+        end
+      end
+    end
+  end
+end

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/location_structure/draft.rb

@@ -1,64 +1,64 @@
-module Ecoportal
-  module API
-    class GraphQL
-      module Builder
-        class LocationStructure
-          class Draft
-            attr_reader :client, :parent
-
-            def initialize(client, parent:)
-              @client = client
-              @parent = parent
-            end
-
-            def nodeClassifications(**kargs, &block)
-              parent.nodeClassifications(**kargs, &block)
-            end
-
-            def create(**kargs, &block)
-              createMutation.query(**kargs, &block)
-            end
-
-            def addCommands(**kargs, &block)
-              addCommandsMutation.query(**kargs, &block)
-            end
-
-            def delete(**kargs, &block)
-              deleteMutation.query(**kargs, &block)
-            end
-
-            def publish(**kargs, &block)
-              publishMutation.query(**kargs, &block)
-            end
-
-            def DropBadCommands(**kargs, &block)
-              dropBadCommandsMutation.query(**kargs, &block)
-            end
-
-            private
-
-            def createMutation
-              Mutation::LocationStructure::Draft::Create.new(client)
-            end
-
-            def addCommandsMutation
-              Mutation::LocationStructure::Draft::AddCommands.new(client)
-            end
-
-            def deleteMutation
-              Mutation::LocationStructure::Draft::Delete.new(client)
-            end
-
-            def publishMutation
-              Mutation::LocationStructure::Draft::Publish.new(client)
-            end
-
-            def dropBadCommandsMutation
-              Mutation::LocationStructure::Draft::DropBadCommands.new(client)
-            end
-          end
-        end
-      end
-    end
-  end
-end
+module Ecoportal
+  module API
+    class GraphQL
+      module Builder
+        class LocationStructure
+          class Draft
+            attr_reader :client, :parent
+
+            def initialize(client, parent:)
+              @client = client
+              @parent = parent
+            end
+
+            def nodeClassifications(**kargs, &block)
+              parent.nodeClassifications(**kargs, &block)
+            end
+
+            def create(**kargs, &block)
+              createMutation.query(**kargs, &block)
+            end
+
+            def addCommands(**kargs, &block)
+              addCommandsMutation.query(**kargs, &block)
+            end
+
+            def delete(**kargs, &block)
+              deleteMutation.query(**kargs, &block)
+            end
+
+            def publish(**kargs, &block)
+              publishMutation.query(**kargs, &block)
+            end
+
+            def DropBadCommands(**kargs, &block)
+              dropBadCommandsMutation.query(**kargs, &block)
+            end
+
+            private
+
+            def createMutation
+              Mutation::LocationStructure::Draft::Create.new(client)
+            end
+
+            def addCommandsMutation
+              Mutation::LocationStructure::Draft::AddCommands.new(client)
+            end
+
+            def deleteMutation
+              Mutation::LocationStructure::Draft::Delete.new(client)
+            end
+
+            def publishMutation
+              Mutation::LocationStructure::Draft::Publish.new(client)
+            end
+
+            def dropBadCommandsMutation
+              Mutation::LocationStructure::Draft::DropBadCommands.new(client)
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -1,40 +1,40 @@
-module Ecoportal
-  module API
-    class GraphQL
-      module Builder
-        class LocationStructure
-          attr_reader :client
-
-          def initialize(client)
-            @client = client
-          end
-
-          def nodeClassifications(**kargs, &block)
-            query_model = Query::LocationClassifications.new(client)
-            query_model.query(**kargs, &block)
-          end
-
-          def applyCommandsInput
-            Input::LocationStructure::ApplyCommands.new
-          end
-
-          def applyCommands(**kargs, &block)
-            applyCommandsMutation.query(**kargs, &block)
-          end
-
-          def draft
-            LocationStructure::Draft.new(client, parent: self)
-          end
-
-          private
-
-          def applyCommandsMutation
-            Mutation::LocationStructure::ApplyCommands.new(client)
-          end
-        end
-      end
-    end
-  end
-end
-
-require_relative 'location_structure/draft'
+module Ecoportal
+  module API
+    class GraphQL
+      module Builder
+        class LocationStructure
+          attr_reader :client
+
+          def initialize(client)
+            @client = client
+          end
+
+          def nodeClassifications(**kargs, &block)
+            query_model = Query::LocationClassifications.new(client)
+            query_model.query(**kargs, &block)
+          end
+
+          def applyCommandsInput
+            Input::LocationStructure::ApplyCommands.new
+          end
+
+          def applyCommands(**kargs, &block)
+            applyCommandsMutation.query(**kargs, &block)
+          end
+
+          def draft
+            LocationStructure::Draft.new(client, parent: self)
+          end
+
+          private
+
+          def applyCommandsMutation
+            Mutation::LocationStructure::ApplyCommands.new(client)
+          end
+        end
+      end
+    end
+  end
+end
+
+require_relative 'location_structure/draft'

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