ecoportal-api-graphql 1.3.10 → 1.3.12

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

@@ -1,79 +1,85 @@
-module Ecoportal
-  module API
-    class GraphQL
-      module Base
-        module Page
-          # Wraps an array of raw section docs as typed Section objects.
-          # Provides v2-compatible access patterns:
-          #   sections.get_by_type(:content_section)
-          #   sections.doc                           — raw doc array
-          #   sections.ordered                       — sections in response order
-          #   sections.each { |s| s.components ... }
-          class SectionCollection
-            include Enumerable
-
-            def initialize(sections_array)
-              @sections = Array(sections_array).map { |s| Section.new(s) }
-            end
-
-            def self.from_doc(raw_array)
-              new(Array(raw_array))
-            end
-
-            # Filter by section type. Accepts symbol (:content_section / :split_section)
-            # or string ('ContentSection' / 'SplitSection'). Case-insensitive, underscore-tolerant.
-            def get_by_type(type_key)
-              target = normalise_type(type_key)
-              @sections.select { |s| normalise_type(s.type) == target }
-            end
-
-            # Find section by heading (case-insensitive).
-            def get_by_heading(heading)
-              @sections.find { |s| s.heading.to_s.downcase == heading.to_s.downcase }
-            end
-
-            # Raw doc array — v2 compat (scripts iterate sections.doc).
-            def doc
-              @sections.map(&:doc)
-            end
-
-            # Sections in response order (already ordered from server).
-            def ordered
-              @sections
-            end
-
-            # All data fields across every section in this collection (memoized).
-            def components
-              @components ||= begin
-                all_docs = @sections.flat_map do |s|
-                  (s.doc['dataFields'] || []) +
-                    (s.doc['leftDataFields']  || []) +
-                    (s.doc['rightDataFields'] || [])
-                end
-                DataField::Collection.from_doc(all_docs)
-              end
-            end
-
-            def each(&block)
-              @sections.each(&block)
-            end
-
-            def empty?
-              @sections.empty?
-            end
-
-            def length
-              @sections.length
-            end
-
-            private
-
-            def normalise_type(type_key)
-              type_key.to_s.downcase.delete('_') if type_key
-            end
-          end
-        end
-      end
-    end
-  end
-end
+module Ecoportal
+  module API
+    class GraphQL
+      module Base
+        module Page
+          # Wraps an array of raw section docs as typed Section objects.
+          # Provides v2-compatible access patterns:
+          #   sections.get_by_type(:content_section)
+          #   sections.doc                           — raw doc array
+          #   sections.ordered                       — sections in response order
+          #   sections.each { |s| s.components ... }
+          class SectionCollection
+            include Enumerable
+
+            def initialize(sections_array)
+              @sections = Array(sections_array).map { |s| Section.new(s) }
+            end
+
+            def self.from_doc(raw_array)
+              new(Array(raw_array))
+            end
+
+            # Filter by section type. Accepts symbol (:content_section / :split_section)
+            # or string ('ContentSection' / 'SplitSection'). Case-insensitive, underscore-tolerant.
+            def get_by_type(type_key)
+              target = normalise_type(type_key)
+              @sections.select { |s| normalise_type(s.type) == target }
+            end
+
+            # Find section by heading (case-insensitive).
+            def get_by_heading(heading)
+              @sections.find { |s| s.heading.to_s.downcase == heading.to_s.downcase }
+            end
+
+            # Find a section by its id (v2 compat: sections.get_by_id). Returns the section or nil.
+            def get_by_id(id)
+              wanted = id.to_s
+              @sections.find { |s| s.id.to_s == wanted }
+            end
+
+            # Raw doc array — v2 compat (scripts iterate sections.doc).
+            def doc
+              @sections.map(&:doc)
+            end
+
+            # Sections in response order (already ordered from server).
+            def ordered
+              @sections
+            end
+
+            # All data fields across every section in this collection (memoized).
+            def components
+              @components ||= begin
+                all_docs = @sections.flat_map do |s|
+                  (s.doc['dataFields'] || []) +
+                    (s.doc['leftDataFields']  || []) +
+                    (s.doc['rightDataFields'] || [])
+                end
+                DataField::Collection.from_doc(all_docs)
+              end
+            end
+
+            def each(&block)
+              @sections.each(&block)
+            end
+
+            def empty?
+              @sections.empty?
+            end
+
+            def length
+              @sections.length
+            end
+
+            private
+
+            def normalise_type(type_key)
+              type_key.to_s.downcase.delete('_') if type_key
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -1,17 +1,17 @@
-module Ecoportal
-  module API
-    class GraphQL
-      module Base
-        # 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
-          passkey :id
-          passthrough :name, :registerId
-          passboolean :global
-          passarray   :fieldConfigurations
-          passthrough :sorter # { key:, direction:, missing: }
-        end
-      end
-    end
-  end
-end
+module Ecoportal
+  module API
+    class GraphQL
+      module Base
+        # 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
+          passkey :id
+          passthrough :name, :registerId
+          passboolean :global
+          passarray   :fieldConfigurations
+          passthrough :sorter # { key:, direction:, missing: }
+        end
+      end
+    end
+  end
+end

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

@@ -1,18 +1,18 @@
-module Ecoportal
-  module API
-    class GraphQL
-      module Base
-        class Register < Logic::BaseModel
-          passkey :id
-          passthrough :name, :iconName, :moduleType, :registerStatus
-          passthrough :descriptionText, :descriptionImageUrl
-          passboolean :shown, :creatable, :attachable, :permissioned
-          passboolean :contentShareable, :enableEmailOut, :isMobile
-          passboolean :restrictTemplatesAmount
-          passthrough :restrictedAmountOfTemplates
-          passarray   :filterTags
-        end
-      end
-    end
-  end
-end
+module Ecoportal
+  module API
+    class GraphQL
+      module Base
+        class Register < Logic::BaseModel
+          passkey :id
+          passthrough :name, :iconName, :moduleType, :registerStatus
+          passthrough :descriptionText, :descriptionImageUrl
+          passboolean :shown, :creatable, :attachable, :permissioned
+          passboolean :contentShareable, :enableEmailOut, :isMobile
+          passboolean :restrictTemplatesAmount
+          passthrough :restrictedAmountOfTemplates
+          passarray   :filterTags
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,174 @@
+module Ecoportal
+  module API
+    class GraphQL
+      module Builder
+        # Build-from-scratch emitter for a template/workflow: turns a DECLARATIVE spec
+        # (stages -> sections -> fields -> options / config / gauge-stops) into an ordered batch of
+        # built `WorkflowCommand` hashes, ready for `Builder::Template#create(commands:)` /
+        # `#update(model, commands:)` (which wrap `executeWorkflowCommands`).
+        #
+        # This is the gem-level, reusable BUILD emitter (previously a one-off in eco-helpers samples).
+        # It shares ONE emission layer with the DIFF-DEPLOY pipeline: both produce an ordered
+        # `WorkflowCommand` batch, and both use the SAME `placeholderId` id-threading primitive that
+        # `Diff::CommandSynthesizer` uses — a newly-created node is addressed by a client-chosen
+        # `placeholderId`, and every later command in the same batch that references it substitutes
+        # that placeholder (the server has not assigned real ids yet). Here every node is brand new,
+        # so the whole batch is threaded through placeholders.
+        #
+        # SPEC SHAPE (all keys optional unless noted; only VALID command inputs are emitted):
+        #
+        #   {
+        #     stages: [
+        #       { name: 'Report', ordering: 0, sections: [        # addStage(name, ordering)
+        #         { layout: 'ONE_COLUMN', fields: [               # addSection(layout) + addStageSection
+        #           { field_type: 'PlainText', label: 'Description', column: 0,
+        #             description: 'ID:token' },   # addField (+ editFieldConfiguration for description)
+        #           { field_type: 'Select', label: 'Severity',
+        #             options: [ { label: 'Low', weight: 0 }, ... ],                # addSelectFieldOption
+        #             config: { select: { multiple: false } } },                   # editFieldConfiguration(byType:)
+        #           { field_type: 'Gauge', label: 'Risk',
+        #             stops: [ { threshold: 0, color: '#0f0' }, ... ],              # addGaugeFieldStop
+        #             config: { gauge: { max: 100.0 } } }
+        #         ] }
+        #       ] }
+        #     ]
+        #   }
+        #
+        # ORDER — addStage -> addSection -> addStageSection -> addField -> (addSelectFieldOption |
+        # addGaugeFieldStop | editFieldConfiguration). This is the dependency-safe order the workflow
+        # command bus expects; placeholderId resolution makes the intra-batch references valid.
+        #
+        # SAFETY — only keys present in each command input's VALID_KEYS are emitted (the input classes
+        # slice + compact). A spec key with no corresponding command input is dropped, not fabricated.
+        # `field_type` shape and per-type config (`byType`) are NOT invented: config is passed through
+        # under its byType sub-hash exactly as given (the caller supplies confirmed byType keys), and
+        # is emitted only for a field that carries one.
+        class TemplateBuilder
+          # @param spec [Hash] the declarative template spec (see class doc). String or symbol keys.
+          def initialize(spec)
+            @spec         = symbolize(spec || {})
+            @commands     = []
+            @counter      = 0
+            @built        = false
+          end
+
+          # Ordered Array of built command hashes ({ commandKey => input }), placeholder-threaded.
+          def commands
+            return @commands if @built
+
+            @built = true
+            build_all
+          end
+
+          # Ready to hand to `Builder::Template#create(commands: builder.to_commands)`.
+          alias_method :to_commands, :commands
+
+          def to_h
+            { commands: commands }
+          end
+
+          private
+
+          def build_all
+            Array(@spec[:stages]).each_with_index { |stage, idx| emit_stage(stage, idx) }
+            @commands
+          end
+
+          def emit_stage(stage, index)
+            stage_ph = placeholder(:stg)
+            add(:addStage, name: stage[:name], ordering: stage.fetch(:ordering, index), placeholderId: stage_ph)
+            Array(stage[:sections]).each { |section| emit_section(section, stage_ph) }
+          end
+
+          def emit_section(section, stage_ph)
+            section_ph = placeholder(:sec)
+            add(:addSection, layout: section[:layout], placeholderId: section_ph)
+            # Attach the freshly-created section to its (freshly-created) stage.
+            add(:addStageSection, stageId: stage_ph, sectionId: section_ph)
+            emit_section_heading(section, section_ph)
+            Array(section[:fields]).each { |field| emit_field(field, stage_ph, section_ph) }
+          end
+
+          # A section's heading is not an addSection input; set it via editSectionHeader after create.
+          def emit_section_heading(section, section_ph)
+            heading = section[:heading]
+            return if heading.nil?
+
+            add(:editSectionHeader, sectionId: section_ph, header: heading)
+          end
+
+          def emit_field(field, stage_ph, section_ph)
+            field_ph = placeholder(:fld)
+            add(:addField,
+                fieldType:     field[:field_type] || field[:fieldType],
+                label:         field[:label],
+                stageId:       stage_ph,
+                sectionId:     section_ph,
+                column:        field[:column],
+                placeholderId: field_ph)
+            emit_description(field, field_ph)
+            emit_options(field, field_ph)
+            emit_stops(field, field_ph)
+            emit_config(field, field_ph)
+          end
+
+          # A field's `description` is NOT an addField input (the schema's WorkflowAddFieldInput has
+          # no `description` key — VERIFIED against the 20260605 dump). It is a top-level key of
+          # editFieldConfiguration, so we persist it with a follow-up editFieldConfiguration
+          # addressed to the freshly-created field placeholder. Emitted only when supplied. This is
+          # the seam the CSV/hidden-field identity token rides on. NOTE: `required` has no schema
+          # input key at all, so it is intentionally NOT emitted (a spec `required:` is ignored).
+          def emit_description(field, field_ph)
+            description = field[:description]
+            return if description.nil?
+
+            add(:editFieldConfiguration, data_field_id: field_ph, description: description)
+          end
+
+          def emit_options(field, field_ph)
+            Array(field[:options]).each do |opt|
+              add(:addSelectFieldOption, data_field_id: field_ph, label: opt[:label], weight: opt[:weight])
+            end
+          end
+
+          def emit_stops(field, field_ph)
+            Array(field[:stops]).each do |stop|
+              add(:addGaugeFieldStop, data_field_id: field_ph, threshold: stop[:threshold], color: stop[:color])
+            end
+          end
+
+          # Per-type field configuration passed through under its byType sub-hash exactly as supplied
+          # (e.g. { select: { multiple: true } }, { gauge: { max: 100.0 } }). Emitted only when
+          # present; keys are validated/sliced by the EditFieldConfiguration input, never fabricated.
+          def emit_config(field, field_ph)
+            config = field[:config]
+            return if config.nil? || config.empty?
+
+            add(:editFieldConfiguration, data_field_id: field_ph, byType: symbolize(config))
+          end
+
+          # Build one command and append it. Reuses the SAME builder the diff synthesizer uses, so
+          # BUILD and DIFF-DEPLOY emit through one layer.
+          def add(command_key, **kwargs)
+            @commands << Ecoportal::API::GraphQL::Input::WorkflowCommand.build(command_key, **kwargs)
+          end
+
+          # A deterministic client-chosen placeholderId — the id-threading primitive shared with the
+          # diff synthesizer. Prefix marks the node kind for readability of the emitted batch.
+          def placeholder(prefix)
+            @counter += 1
+            "ph_#{prefix}_#{@counter}"
+          end
+
+          def symbolize(value)
+            case value
+            when Hash  then value.each_with_object({}) { |(k, v), h| h[k.to_sym] = symbolize(v) }
+            when Array then value.map { |e| symbolize(e) }
+            else value
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -1,16 +1,17 @@
-module Ecoportal
-  module API
-    class GraphQL
-      module Builder
-      end
-    end
-  end
-end
-
-require_relative 'builder/location_structure'
-require_relative 'builder/action'
-require_relative 'builder/contractor_entity'
-require_relative 'builder/register'
-require_relative 'builder/page'
-require_relative 'builder/kickstand'
-require_relative 'builder/template'
+module Ecoportal
+  module API
+    class GraphQL
+      module Builder
+      end
+    end
+  end
+end
+
+require_relative 'builder/location_structure'
+require_relative 'builder/action'
+require_relative 'builder/contractor_entity'
+require_relative 'builder/register'
+require_relative 'builder/page'
+require_relative 'builder/kickstand'
+require_relative 'builder/template'
+require_relative 'builder/template_builder'

data/lib/ecoportal/api/graphql/compat/filter_translator.rb

@@ -9,9 +9,12 @@ module Ecoportal
         # callers may also pass already-translated hashes or SearchConf instances directly.
         #
         # v2 → GraphQL translation table:
-        #   date_filter     lbound/ubound → gte/lte (ES date range)
+        #   date_filter     lbound/ubound → gte/lte; Date FIELD (key 'date.zXXXX') →
+        #                   range_date_filter + membranes.date path; system date → date_filter
         #   text_filter     {query, key} → match_filter {key, value} (partial text)
-        #   options_filter  {chosen, key, mode} → one_of_filter {key, values} (or none_of_filter)
+        #   options_filter  Select FIELD (key 'select_str.zXXXX') → has_any_filter
+        #                   {key, path, field_key: 'selected', values} (doesnt_have_any_filter to
+        #                   exclude); system option key → one_of_filter/none_of_filter {key, values}
         #   tag_filter      passed through (same ES backend, same format)
         #   register_filter passed through
         #   and_filter / or_filter  passed through
@@ -43,12 +46,18 @@ module Ecoportal
             # exact one: it matches the field's `.exact` keyword subfield (backend
             # NewEp::Es::Filters::Pages::IsFilter → ExactFilter on `membranes.<type>.exact`),
             # whereas match_filter/contains_filter hit the analyzed `.value` and miss exact SKUs.
-            # Requires `path` (membranes.<type>) — derived from the key prefix when not given.
+            # A register FIELD key ('plain_text.zXXXX') needs the nested membranes.<type> path;
+            # a SYSTEM key (external_id/id/state/creator_id/source) must NOT carry a path — the
+            # backend routes it to Global::ExactFilter which joins [@path,@key] into the term key,
+            # so a spurious 'membranes.external_id' yields term 'membranes.external_id.external_id'
+            # → 0 results (proof: pages/is_filter.rb:36-55 passes path: @path to Global::ExactFilter;
+            # global/exact_filter.rb:18 builds the term as [@path, @key].compact.join(".")).
             # CAVEAT: case-insensitive and only the first 64 chars are significant (values are
             # lowercased + truncated at index time). No case-sensitive/>64-char exact exists.
             def translate_exact_filter(filter)
               key   = filter['key']   || filter[:key]
-              path  = filter['path']  || filter[:path] || membrane_path_for(key)
+              path  = filter['path']  || filter[:path]
+              path  ||= membrane_path_for(key) if membrane_field?(key)
               value = filter['value'] || filter[:value] || filter['query'] || filter[:query]
               { operation: 'is_filter', params: { key: key, path: path, value: value }.compact }
             end
@@ -59,6 +68,14 @@ module Ecoportal
               prefix.empty? ? nil : "membranes.#{prefix}"
             end
 
+            # A register FIELD key carries a `<type>.<hash>` shape (e.g. 'date.zab1bddc3',
+            # 'select_str.z223beb6d'); system/top-level keys (created_at, id, external_id) have
+            # no field-type prefix. Field filters need the nested membranes.<type> path (and,
+            # for options, a field_key), which system filters do not.
+            def membrane_field?(key)
+              key.to_s.include?('.')
+            end
+
             # v2 text_filter {query, key} → GraphQL match_filter (partial/full-text on key).
             def translate_text_filter(filter)
               {
@@ -70,34 +87,52 @@ module Ecoportal
               }
             end
 
-            # v2 options_filter {chosen, key, mode} → one_of_filter (match any chosen) or
-            # none_of_filter (exclude) — both take {key, values}.
+            # v2 options_filter {chosen, key, mode} → GraphQL.
+            # A register Select FIELD (key like 'select_str.zXXXX') filters via
+            # has_any_filter / doesnt_have_any_filter over its nested path
+            # (membranes.select_str) with field_key 'selected' and the chosen option ids as
+            # `values` (backend NewEp::Es::Filters::Pages::*::HasAnyFilter). A system/top-level
+            # option key (e.g. 'id') keeps one_of_filter / none_of_filter with {key, values}.
             def translate_options_filter(filter)
-              mode = (filter['mode'] || filter[:mode]).to_s.downcase
-              op   = %w[none exclude not not_in].include?(mode) ? 'none_of_filter' : 'one_of_filter'
-              {
-                operation: op,
-                params:    {
-                  key:    filter['key'] || filter[:key],
-                  values: Array(filter['chosen'] || filter[:chosen])
-                }
-              }
+              key     = filter['key'] || filter[:key]
+              values  = Array(filter['chosen'] || filter[:chosen])
+              exclude = exclude_mode?(filter)
+
+              unless membrane_field?(key)
+                op = exclude ? 'none_of_filter' : 'one_of_filter'
+                return { operation: op, params: { key: key, values: values } }
+              end
+
+              op        = exclude ? 'doesnt_have_any_filter' : 'has_any_filter'
+              path      = filter['path']      || filter[:path]      || membrane_path_for(key)
+              field_key = filter['field_key'] || filter[:field_key] || 'selected'
+              { operation: op, params: { key: key, path: path, field_key: field_key, values: values } }
             end
 
+            # v2 date_filter → GraphQL. A register Date FIELD (key like 'date.zXXXX') filters
+            # via range_date_filter on its nested path (membranes.date); a system/top-level date
+            # (created_at/updated_at) uses date_filter. Both share range params (gte/lte/time_zone)
+            # — range_date_filter additionally carries `path` (backend BaseRangeDateFilter < DateFilter).
             def translate_date_filter(filter)
-              key = filter['key'] || filter[:key]
-              {
-                operation: 'date_filter',
-                params:    {
-                  key:       key,
-                  time_zone: filter['time_zone'] || filter[:time_zone] || 'UTC'
-                }.tap do |params|
-                  lbound = filter['lbound'] || filter[:lbound]
-                  ubound = filter['ubound'] || filter[:ubound]
-                  params[:gte] = lbound if lbound
-                  params[:lte] = ubound if ubound
-                end
-              }
+              key   = filter['key'] || filter[:key]
+              field = membrane_field?(key)
+              path  = filter['path'] || filter[:path]
+              path  ||= membrane_path_for(key) if field
+
+              params = { key: key, time_zone: filter['time_zone'] || filter[:time_zone] || 'UTC' }
+              params[:path] = path if path
+              lbound = filter['lbound'] || filter[:lbound]
+              ubound = filter['ubound'] || filter[:ubound]
+              params[:gte] = lbound if lbound
+              params[:lte] = ubound if ubound
+
+              { operation: field ? 'range_date_filter' : 'date_filter', params: params }
+            end
+
+            # "exclude" style modes map to the negative filter operation.
+            def exclude_mode?(filter)
+              mode = (filter['mode'] || filter[:mode]).to_s.downcase
+              %w[none exclude not not_in].include?(mode)
             end
           end
         end