ecoportal-api-graphql 1.3.5 → 1.3.17

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

@@ -1,61 +1,61 @@
-module Ecoportal
-  module API
-    class GraphQL
-      module Query
-        class LocationStructure < Logic::Query
-          accepted_params :id
-          accepted_params :includeArchivedNodes, default: true
-
-          field_name :structure
-
-          class_resolver :item_class, Model::LocationStructure
-
-          private
-
-          def basic_block(&block)
-            final_block = block || default_query_block
-            proc {
-              query(
-                id:                   :id!,
-                includeArchivedNodes: :boolean
-              ) {
-                currentOrganization {
-                  locations {
-                    structure(id: :id, &final_block)
-                  }
-                }
-              }
-            }
-          end
-
-          # At the moment it always retrieves archived nodes!!
-          # @note this is on purpose, as via API
-          #   there isn't much sense in not including archived nodes.
-          def default_query_block
-            proc {
-              id
-              name
-              archived
-              weight
-              updatedAt
-              visitorManagementEnabled
-              nodes(
-                includeArchived: :includeArchivedNodes
-              ) {
-                ___Ecoportal__API__GraphQL__Fragment__LocationNode
-              }
-              drafts {
-                id
-                createdAt
-                name
-                notes
-              }
-            }
-          end
-        end
-      end
-    end
-  end
-end
-
-require_relative 'location_structure/draft'
+module Ecoportal
+  module API
+    class GraphQL
+      module Query
+        class LocationStructure < Logic::Query
+          accepted_params :id
+          accepted_params :includeArchivedNodes, default: true
+
+          field_name :structure
+
+          class_resolver :item_class, Model::LocationStructure
+
+          private
+
+          def basic_block(&block)
+            final_block = block || default_query_block
+            proc {
+              query(
+                id:                   :id!,
+                includeArchivedNodes: :boolean
+              ) {
+                currentOrganization {
+                  locations {
+                    structure(id: :id, &final_block)
+                  }
+                }
+              }
+            }
+          end
+
+          # At the moment it always retrieves archived nodes!!
+          # @note this is on purpose, as via API
+          #   there isn't much sense in not including archived nodes.
+          def default_query_block
+            proc {
+              id
+              name
+              archived
+              weight
+              updatedAt { dateTime timeZone }
+              visitorManagementEnabled
+              nodes(
+                includeArchived: :includeArchivedNodes
+              ) {
+                spread :LocationNode
+              }
+              drafts {
+                id
+                createdAt
+                name
+                notes
+              }
+            }
+          end
+        end
+      end
+    end
+  end
+end
+
+require_relative 'location_structure/draft'

data/lib/ecoportal/api/graphql/query/location_structures.rb

@@ -1,57 +1,57 @@
-module Ecoportal
-  module API
-    class GraphQL
-      module Query
-        class LocationStructures < Logic::QueryArray
-          accepted_params :includeArchived, :includeUnpublished, default: false
-          accepted_params :includeArchivedNodes, default: true
-
-          field_name :structures
-
-          class_resolver :item_class, Model::LocationStructure
-
-          private
-
-          def basic_block(&block)
-            final_block = block || default_query_block
-            proc {
-              query(
-                includeArchived:      :boolean,
-                includeUnpublished:   :boolean,
-                includeArchivedNodes: :boolean
-              ) {
-                currentOrganization {
-                  locations {
-                    structures(
-                      includeArchived:    :includeArchived,
-                      includeUnpublished: :includeUnpublished,
-                      &final_block
-                    )
-                  }
-                }
-              }
-            }
-          end
-
-          # At the moment it always retrieves archived nodes!!
-          # @note this is on purpose, as via API
-          #   there isn't much sense in not including archived nodes.
-          def default_query_block
-            proc {
-              id
-              name
-              archived
-              weight
-              visitorManagementEnabled
-              nodes(
-                includeArchived: :includeArchivedNodes
-              ) {
-                ___Ecoportal__API__GraphQL__Fragment__LocationNode
-              }
-            }
-          end
-        end
-      end
-    end
-  end
-end
+module Ecoportal
+  module API
+    class GraphQL
+      module Query
+        class LocationStructures < Logic::QueryArray
+          accepted_params :includeArchived, :includeUnpublished, default: false
+          accepted_params :includeArchivedNodes, default: true
+
+          field_name :structures
+
+          class_resolver :item_class, Model::LocationStructure
+
+          private
+
+          def basic_block(&block)
+            final_block = block || default_query_block
+            proc {
+              query(
+                includeArchived:      :boolean,
+                includeUnpublished:   :boolean,
+                includeArchivedNodes: :boolean
+              ) {
+                currentOrganization {
+                  locations {
+                    structures(
+                      includeArchived:    :includeArchived,
+                      includeUnpublished: :includeUnpublished,
+                      &final_block
+                    )
+                  }
+                }
+              }
+            }
+          end
+
+          # At the moment it always retrieves archived nodes!!
+          # @note this is on purpose, as via API
+          #   there isn't much sense in not including archived nodes.
+          def default_query_block
+            proc {
+              id
+              name
+              archived
+              weight
+              visitorManagementEnabled
+              nodes(
+                includeArchived: :includeArchivedNodes
+              ) {
+                spread :LocationNode
+              }
+            }
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,45 @@
+module Ecoportal
+  module API
+    class GraphQL
+      module Query
+        class Page < Logic::Query
+          field_name :page
+          # Response nests under currentOrganization.page; needed when instantiated
+          # directly (e.g. Compat::Pages#get) rather than via the currentOrganization proxy.
+          base_path 'currentOrganization'
+
+          accepted_params :id
+          class_resolver :item_class, 'Ecoportal::API::GraphQL::Model::PageUnion'
+
+          private
+
+          def basic_block(&block)
+            page_block = block || default_block
+            # CommonPageUnion's directives ($content/$only_content/$fields) are declared
+            # here with the defaults for a single-page read (content + field definitions).
+            # showHiddenData defaults true so reads include hidden/deindexed fields — v2
+            # parity (scripts see every field) and matches the front-end edit load. The
+            # server omits hidden fields from `page(id:)` when this is false/absent.
+            proc {
+              query(
+                id:             :id!,
+                showHiddenData: 'Boolean = true',
+                content:        'Boolean = true',
+                only_content:   'Boolean = false',
+                fields:         'Boolean = true'
+              ) {
+                currentOrganization {
+                  page(id: :id, showHiddenData: :showHiddenData, &page_block)
+                }
+              }
+            }
+          end
+
+          def default_block
+            proc { spread :CommonPageUnion }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ecoportal/api/graphql/query/page_delta.rb

@@ -0,0 +1,47 @@
+module Ecoportal
+  module API
+    class GraphQL
+      module Query
+        # Cache-invalidation query: given a list of (id, deltaAt) pairs, returns
+        # which pages have been UPDATED since that timestamp, are NOT_FOUND (deleted/
+        # inaccessible), or are NEW (id not recognised by the server).
+        #
+        # Usage:
+        #   Query::PageDelta.new(client).query(
+        #     deltaInput: [
+        #       { id: 'abc', deltaAt: '2026-01-01T00:00:00Z' },
+        #       { id: 'def', deltaAt: '2026-03-15T12:00:00Z' }
+        #     ]
+        #   )
+        #   # => [DeltaResult(id: 'abc', delta: 'UPDATED'), ...]
+        class PageDelta < Logic::QueryArray
+          field_name :pageDelta
+
+          accepted_params :deltaInput, :searchConf
+
+          class_resolver :item_class, 'Ecoportal::API::GraphQL::Base::DeltaResult'
+
+          private
+
+          def basic_block(&block)
+            item_block = block || default_block
+            proc {
+              query(deltaInput: :'[DeltaInput!]!', searchConf: :Search) {
+                currentOrganization {
+                  pageDelta(deltaInput: :deltaInput, searchConf: :searchConf, &item_block)
+                }
+              }
+            }
+          end
+
+          def default_block
+            proc {
+              id
+              delta
+            }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ecoportal/api/graphql/query/page_with_forces.rb

@@ -0,0 +1,49 @@
+module Ecoportal
+  module API
+    class GraphQL
+      module Query
+        # Fetches a single page by ID, including its full forces array.
+        # Used by OozeRedirect::ForceCompat instead of the standard Query::Page
+        # so that `page.forces.get_by_name(name)` returns populated data.
+        #
+        # Usage (via ForceCompat — not typically called directly):
+        #   page = Query::PageWithForces.new(client).query(id: page_id)
+        #   force = page.forces.get_by_name('Workflow (S1)').first
+        class PageWithForces < Logic::Query
+          field_name :page
+
+          accepted_params :id
+          class_resolver :item_class, 'Ecoportal::API::GraphQL::Model::PageUnion'
+
+          private
+
+          def basic_block(&block)
+            page_block = block || default_block
+            proc {
+              query(id: :id!) {
+                currentOrganization {
+                  page(id: :id, &page_block)
+                }
+              }
+            }
+          end
+
+          # `currentOrganization.page(id:)` returns a PageUnion — selecting `forces` on it
+          # directly is invalid GraphQL ("Selections can't be made directly on unions").
+          # `forces` lives on BasePageInterface (which every union member implements), so it
+          # goes through an inline type condition, same as `PageFields` does.
+          def default_block
+            proc {
+              spread :PageFields
+              spread on: :BasePageInterface do
+                forces {
+                  spread :ForceFields
+                }
+              end
+            }
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,59 @@
+module Ecoportal
+  module API
+    class GraphQL
+      module Query
+        # DB-backed full-data org search — returns PageUnion nodes with patchVer and field IDs.
+        # Required pre-update fetch: always use this (not RegisterPreviewPages) before updatePage.
+        # See the repo's internal docs — "The Required Pattern: Find Before Mutate".
+        class Pages < Logic::QueryConnection
+          field_name :pages
+          # Response nests under currentOrganization.pages; needed when instantiated
+          # directly (e.g. Compat::Pages#each) rather than via the currentOrganization proxy.
+          base_path 'currentOrganization'
+
+          class_resolver :item_class, 'Ecoportal::API::GraphQL::Model::PageUnion'
+          class_resolver :connection_class, 'Ecoportal::API::GraphQL::Connection::Page'
+
+          private
+
+          def basic_block(&block)
+            connection_block = block || default_connection_block
+            proc {
+              query(
+                searchConf: :Search,
+                after:      :string,
+                before:     :string,
+                first:      :int,
+                last:       :int
+              ) {
+                currentOrganization {
+                  pages(
+                    searchConf: :searchConf,
+                    after:      :after,
+                    before:     :before,
+                    first:      :first,
+                    last:       :last,
+                    &connection_block
+                  )
+                }
+              }
+            }
+          end
+
+          def default_connection_block
+            proc {
+              totalCount
+              pageInfo {
+                endCursor
+                hasNextPage
+              }
+              nodes {
+                spread :PageFields
+              }
+            }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ecoportal/api/graphql/query/pages_workflow_commands.rb

@@ -0,0 +1,65 @@
+module Ecoportal
+  module API
+    class GraphQL
+      module Query
+        # Paginated command log for a page's PagesWorkflow.
+        # Returns PagesWorkflowCommandInterface nodes — each command applied to
+        # the workflow builder (change, changeMessage, esChange concrete types).
+        #
+        # Usage:
+        #   q = Query::PagesWorkflowCommands.new(client)
+        #   q.each(id: page.id, first: 50) { |cmd| puts cmd.doc['commandAction'] }
+        class PagesWorkflowCommands < Logic::QueryConnection
+          SCHEMA_VERSION = '20260605'.freeze
+
+          field_name :commands
+
+          accepted_params :id, :after, :before, :first, :last
+
+          class_resolver :item_class,       'Ecoportal::API::GraphQL::Base::PagesWorkflow::CommandInterface'
+          class_resolver :connection_class, 'Ecoportal::API::GraphQL::Connection::PagesWorkflowCommand'
+
+          def path
+            %w[currentOrganization page workflow commands]
+          end
+
+          private
+
+          # `page(id:)` returns a PageUnion — selecting `workflow` on it directly is invalid
+          # GraphQL ("Selections can't be made directly on unions"). `workflow` lives on
+          # BasePageInterface, so it goes through an inline type condition. The response shape
+          # is unchanged by the type condition, so `#path` still resolves the connection.
+          def basic_block(&block)
+            connection_block = block || default_connection_block
+            proc {
+              query(id: :id!, after: :string, before: :string, first: :int, last: :int) {
+                currentOrganization {
+                  page(id: :id) {
+                    spread on: :BasePageInterface do
+                      workflow {
+                        commands(after: :after, before: :before, first: :first, last: :last, &connection_block)
+                      }
+                    end
+                  }
+                }
+              }
+            }
+          end
+
+          def default_connection_block
+            proc {
+              totalCount
+              pageInfo {
+                endCursor
+                hasNextPage
+              }
+              nodes {
+                spread :PagesWorkflowCommandFields
+              }
+            }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ecoportal/api/graphql/query/register_preset_views.rb

@@ -0,0 +1,78 @@
+module Ecoportal
+  module API
+    class GraphQL
+      module Query
+        # Lists preset views for a register.
+        # Returns an array of PresetView objects — not paginated (server returns all at once).
+        # Use the returned IDs as `presetViewId` in RegisterPreviewPages queries.
+        #
+        # Usage:
+        #   views = Query::RegisterPresetViews.new(client).query(registerId: 'REG_ID')
+        #   views.map { |v| { id: v.id, name: v.name, global: v.global? } }
+        class RegisterPresetViews < Logic::Query
+          field_name :presetViews
+
+          accepted_params :registerId, :searchConf
+
+          class_resolver :item_class, 'Ecoportal::API::GraphQL::Model::PresetView'
+
+          def path
+            %w[currentOrganization register presetViews]
+          end
+
+          def response_class
+            # presetViews returns an array — wrap in a simple array-like response
+            ArrayResponse
+          end
+
+          # Minimal array wrapper so callers can iterate results with .each / .map
+          class ArrayResponse
+            include Enumerable
+
+            def initialize(raw)
+              klass = Ecoportal::API::GraphQL::Model::PresetView
+              @items = Array(raw).map { |d| klass.new(d) }
+            end
+
+            def each(&block)
+              @items.each(&block)
+            end
+
+            def nodes
+              @items
+            end
+          end
+
+          private
+
+          def basic_block(&block)
+            view_block = block || default_block
+            proc {
+              query(
+                registerId: :id!,
+                searchConf: :Search
+              ) {
+                currentOrganization {
+                  register(id: :registerId) {
+                    presetViews(searchConf: :searchConf, &view_block)
+                  }
+                }
+              }
+            }
+          end
+
+          def default_block
+            proc {
+              id
+              name
+              global
+              registerId
+              sorter { key direction missing }
+              fieldConfigurations { spread :FieldConfiguration }
+            }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ecoportal/api/graphql/query/register_preview_pages.rb

@@ -0,0 +1,83 @@
+module Ecoportal
+  module API
+    class GraphQL
+      module Query
+        # Elasticsearch-backed fast search within a register.
+        # Returns PreviewPage nodes — no field IDs, no patchVer.
+        # Use for metadata lookup (find by externalId, state, location, date).
+        # Switch to Query::Pages (org search) for full data before mutations.
+        #
+        # Supports includeArchived: Boolean (default false).
+        # Supports presetViewId: ID to apply a register PageView preset.
+        class RegisterPreviewPages < Logic::QueryConnection
+          field_name :previewPages
+
+          accepted_params :registerId, :after, :before, :first, :last,
+                          :searchConf, :includeArchived, :presetViewId
+
+          class_resolver :item_class,       'Ecoportal::API::GraphQL::Model::PreviewPage'
+          class_resolver :connection_class, 'Ecoportal::API::GraphQL::Connection::PreviewPage'
+
+          def path
+            %w[currentOrganization register previewPages]
+          end
+
+          private
+
+          def basic_block(&block)
+            connection_block = block || default_connection_block
+            proc {
+              query(
+                registerId:      :id!,
+                after:           :string,
+                before:          :string,
+                first:           :int,
+                last:            :int,
+                searchConf:      :Search,
+                includeArchived: :boolean,
+                presetViewId:    :id
+              ) {
+                currentOrganization {
+                  register(id: :registerId) {
+                    previewPages(
+                      after:           :after,
+                      before:          :before,
+                      first:           :first,
+                      last:            :last,
+                      searchConf:      :searchConf,
+                      includeArchived: :includeArchived,
+                      presetViewId:    :presetViewId,
+                      &connection_block
+                    )
+                  }
+                }
+              }
+            }
+          end
+
+          def default_connection_block
+            proc {
+              totalCount
+              pageInfo {
+                endCursor
+                hasNextPage
+              }
+              nodes {
+                id
+                uid
+                name
+                state
+                archived
+                externalId
+                creatorName
+                createdAt { dateTime timeZone }
+                updatedAt { dateTime timeZone }
+                locations { id name }
+              }
+            }
+          end
+        end
+      end
+    end
+  end
+end