ecoportal-api-graphql 2.2.1 → 3.0.0

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

@@ -1,26 +1,174 @@
 module Ecoportal::API::GraphQL::Base::Page
   class DataField
     # Image gallery field.
-    # ★ WRITE PATH BROKEN (schema-invalid, live-verified 2026-08): `ImageGalleryInput` has no
-    # `fileContainerIds` — it takes `images: [ImageInput]`, attaching via `sourceId`, which is
-    # an `Enzyme::ImageReference::TempImage` (a DIFFERENT upload pipeline than file containers).
-    # Fixing this needs its own design — see the DataField shape-asymmetry review project.
-    # The reader is equally stale: live responses carry `images`, not `fileContainers`.
+    #
+    # ★ FIXED 2026-09 (previously broken -- see `spec/.../image_gallery_characterization_spec.rb`
+    # git history for the prior "WRITE PATH BROKEN" documentation of this defect). Confirmed
+    # against the LIVE ecoPortal server source (read-only, /tmp/work/ecoPortal) that a
+    # gallery image is genuinely NOT a `FileContainer`:
+    #   * `app/graphql/types/fill_in_page/inputs/data_fields/image_gallery_input.rb:5-11` --
+    #     `ImageGalleryInput` has NO `fileContainerIds`; it takes `images: [ImageInput]`.
+    #   * `.../image_galleries/image_input.rb:6-15` -- `ImageInput` takes `sourceId` (a
+    #     `TempImage` id, from the SEPARATE `uploadImage` mutation -- see
+    #     `Mutation::Image::Upload` / `FileUpload::Client#upload_image`), never
+    #     `fileContainerId`.
+    #   * `app/services/new_ep/pages/assign_attributes_service.rb:152-176`
+    #     (`set_image_gallery_attrs`) -- full-replace-by-omission, the SAME trap as
+    #     `FileField`: any current image whose `id` is not echoed back in the write is
+    #     destroyed (`format_removed_ids`).
+    #   * `app/graphql/types/pages/data_fields/image_galleries/image_type.rb` -- `fileName`/
+    #     `fileSize` are NULLABLE even on a successful upload -- a documented upstream bug
+    #     ("images are successfully uploaded but the file name and size are not set in the
+    #     database", per the live schema's own field comment). Any comparison built on these
+    #     two fields must treat a nil on either side as "not a confident match", never a
+    #     positive one.
+    #
+    # READ: `images { id weight downloadUrl caption fileName fileSize uploadId }`
+    # (`imageGalleryField` fragment, `fragment/pages/common_page_union.rb` -- `id`/`weight`
+    # were ADDED alongside this fix; the fragment previously omitted both, which is why no
+    # correct reader was possible before now).
+    #
+    # WRITE: `ImageGalleryInput { id images: [ImageInput] }`; `ImageInput { id weight
+    # sourceId caption fileName sensitiveContent inaccurateDescription
+    # inaccurateExtractedText }`. `as_input` sends every KEPT image back with its FULL
+    # `ImageInput` field set (`#kept_image_input`) -- NOT a bare `{id:}` -- and every NEW one
+    # as `{sourceId:, weight:, fileName:}` -- see `#add_source_images`, the merge-safe writer
+    # (mirrors `FileField#file_container_ids=`'s kept-vs-new split).
+    #
+    # ★ CORRECTED 2026-09 (pre-release, MR !278 unreleased): the bare `{id:}` echo for a kept
+    # image, above, silently dropped every OTHER attribute on that image on the NEXT write
+    # server-side -- `assign_attributes_service.rb#set_image_gallery_attrs` applies `images`
+    # as a FULL REPLACE (see the class header above), so a bare `{id:}` is indistinguishable
+    # from "clear caption/sensitiveContent/etc back to their defaults" for that image, not
+    # "leave it as it is". Matches the org-side reference implementation (a downstream script repo,
+    # commit 482db9c) and the live schema's own `ImageInput` argument list -- the shipped
+    # `ep-api-collections` sample only demonstrates the NEW-image shape (no existing images to
+    # keep), so this shape is pinned to server source + that proven reference, not a captured
+    # kept-echo payload (see EVIDENCE PRECEDENCE note on `#kept_image_input`).
+    #
+    # `images` is deliberately a PLAIN doc reader, not `passarray` -- same reasoning as
+    # `FileField#items` (see that class's header): materialising an ArrayModel writes
+    # `images: []` into the doc of a field read without `$content`, and a phantom-dirty empty
+    # `images` here doesn't always no-op (only the empty-vs-missing-key case is neutralised
+    # by `Diffable::LeafDiffService`'s array-diff fix, MR !106) -- it can still synthesise an
+    # unwanted write for a non-empty phantom read. A plain reader has no such hazard.
     class ImageGallery < DataField
-      passarray :fileContainers # each: { id:, fileName:, url:, ... }
+      # each: { 'id' =>, 'weight' =>, 'downloadUrl' =>, 'caption' =>, 'fileName' =>,
+      #         'fileSize' =>, 'uploadId' => }
+      def images
+        Array(doc['images'])
+      end
+
+      # @return [Array<String>] every image's own item id (its server-assigned id, NOT the
+      #   `uploadId`/`TempImage` id it was created from).
+      def image_ids
+        images.filter_map { |image| image['id'] if image.is_a?(Hash) }
+      end
 
-      def file_container_ids
-        Array(fileContainers).map { |c| c.is_a?(Hash) ? c['id'] : c }.compact
+      # @return [Integer] one past the highest `weight` currently on the field (`0` if the
+      #   field is empty). There is no server-side auto-increment for `weight` (a plain
+      #   Integer field, default `0`) -- callers that want sequential ordering for several new
+      #   images in one write should still call this ONCE and increment locally
+      #   (`#add_source_images` already does).
+      def next_weight
+        return 0 if images.empty?
+
+        images.map { |image| image.is_a?(Hash) ? image['weight'].to_i : 0 }.max + 1
       end
 
-      def file_container_ids=(ids)
-        doc['fileContainers'] = Array(ids).map { |id_val| { 'id' => id_val } }
+      # Merge-safe write: adds NEW images (each referenced by `source_id`, the `TempImage`
+      # id from `FileUpload::Client#upload_image`) while KEEPING every image already loaded
+      # on this field. `images` on `ImageGalleryInput` is a FULL REPLACE server-side -- any
+      # current image whose `id` is not echoed back is destroyed -- so this always keeps
+      # every currently-loaded image's FULL doc entry (untouched -- `#images_input` picks the
+      # `ImageInput`-writable subset out of it later; kept HERE in full so that subset still
+      # has every field to read, rather than collapsing to a bare `{'id' => ...}` that would
+      # throw the other attributes away before `#as_input` ever runs) and appends the new
+      # ones after it, at sequential weights starting at `#next_weight`. Marks the field dirty
+      # (same underlying mechanism as `FileField#file_container_ids=` -- a raw `doc` mutation,
+      # picked up by the generic diff regardless of the `passarray`/plain-reader choice above).
+      #
+      # @param sources [Array<Hash>] one entry per NEW image. Accepts either key style:
+      #   `{source_id:, file_name:}` or `{'sourceId' =>, 'fileName' =>}`. `weight` is assigned
+      #   here, not read from the input -- the caller does not need to compute it.
+      # @return [Array<Hash>] the full resulting `images` doc (kept + added), same value now
+      #   readable via `#images`.
+      def add_source_images(sources)
+        kept  = images.select { |image| image.is_a?(Hash) && image['id'] }
+        start = next_weight
+        added = Array(sources).each_with_index.map do |source, index|
+          {
+            'sourceId' => fetch_key(source, :source_id, 'sourceId'),
+            'weight'   => start + index,
+            'fileName' => fetch_key(source, :file_name, 'fileName')
+          }.compact
+        end
+        doc['images'] = kept + added
       end
 
       def as_input
         return nil unless dirty?
 
-        { imageGallery: { id: id, fileContainerIds: file_container_ids } }
+        {imageGallery: {id: id, images: images_input}}
+      end
+
+      private
+
+      # `images` holds the write shape for a NEW item (`{'sourceId' =>, 'weight' =>,
+      # 'fileName' =>}`, from `#add_source_images`) as-is, and the FULL read doc for a KEPT
+      # item (untouched since the last read) -- `#kept_image_input` narrows the latter down to
+      # exactly what `ImageInput` accepts.
+      def images_input
+        images.filter_map do |image|
+          next unless image.is_a?(Hash)
+
+          if image['sourceId']
+            {sourceId: image['sourceId'], weight: image['weight'], fileName: image['fileName']}.compact
+          elsif image['id']
+            kept_image_input(image)
+          end
+        end
+      end
+
+      # Full-field echo for a KEPT (currently-existing, untouched) image -- REQUIRED because
+      # `ImageGalleryInput.images` is a full replace server-side (`assign_attributes_service.
+      # rb#set_image_gallery_attrs` -> `format_removed_ids`): a bare `{id:}` is read by the
+      # server as "clear every other attribute", not "leave this image as it is".
+      #
+      # EVIDENCE PRECEDENCE (shipped sample -> server source -> gem model): the shipped
+      # a customer collection's "Attach Image to Gallery Field"
+      # sample only demonstrates a BRAND-NEW image (`sourceId`/`weight`/`fileName`, no
+      # existing images on the field to keep) -- it does not capture a kept-image echo. This
+      # shape is therefore pinned to the next level down: the live schema's own `ImageInput`
+      # argument list (`app/graphql/types/fill_in_page/inputs/data_fields/image_galleries/
+      # image_input.rb`: `id weight sourceId caption fileName sensitiveContent
+      # inaccurateDescription inaccurateExtractedText`) plus the org-side reference
+      # implementation already built against those same server facts and merged
+      # (a downstream script repo, commit 482db9c, `#kept_gallery_image_input`) -- not an inference
+      # from this gem's own prior (incorrect) behaviour.
+      #
+      # `sourceId` here is read back from the CURRENT read's `uploadId` -- the read-side name
+      # for the same identifier (a customer collection's integration guide
+      # section 7: "the id changes name between reading and writing"). Every key is sent as
+      # read (never `.compact`-ed away) -- this is an ECHO of the field's current state, so a
+      # nil here means "this attribute is genuinely unset", which is exactly what should be
+      # (re-)written to preserve it unset, not omitted and misread as "clear it".
+      def kept_image_input(image)
+        {
+          id:                      image['id'],
+          sourceId:                image['uploadId'],
+          weight:                  image['weight'],
+          caption:                 image['caption'],
+          fileName:                image['fileName'],
+          sensitiveContent:        image['sensitiveContent'],
+          inaccurateDescription:   image['inaccurateDescription'],
+          inaccurateExtractedText: image['inaccurateExtractedText']
+        }
+      end
+
+      def fetch_key(hash, *keys)
+        keys.each { |k| return hash[k] if hash.is_a?(Hash) && hash.key?(k) }
+        nil
       end
     end
   end

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

@@ -0,0 +1,28 @@
+module Ecoportal
+  module API
+    class GraphQL
+      module Base
+        # The upload-staging model behind `uploadImage` -- explicitly NOT a `FileContainer`.
+        # Verified against the live ecoPortal server schema (read-only,
+        # /tmp/work/ecoPortal): `Types::Files::TempImageType` (`app/graphql/types/files/
+        # temp_image_type.rb`) declares exactly `id s3Key error complete`, backed by
+        # `Enzyme::ImageReference::TempImage` (`app/models/enzyme/image_reference.rb`), a
+        # separate upload-staging Mongoid model from `FileContainer`.
+        #
+        # `complete` starts `false` immediately after `uploadImage` returns and is filled in
+        # later by background processing. A consumer does NOT need to wait for it: confirmed
+        # server-side (`app/services/new_ep/pages/assign_attributes_service.rb`'s
+        # `set_image_gallery_attrs`) that attaching a `TempImage` to an Image Gallery field via
+        # `ImageInput.sourceId` succeeds whether or not `complete?`/`error?` is true yet -- an
+        # incomplete image is accepted and filled in on the record later.
+        class TempImage < Logic::BaseModel
+          read_only!
+
+          passkey     :id
+          passthrough :s3Key, :error
+          passboolean :complete
+        end
+      end
+    end
+  end
+end

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

@@ -15,6 +15,7 @@ require_relative 'base/location_structure'
 require_relative 'base/person_member'
 require_relative 'base/file_attachment'
 require_relative 'base/file_container'
+require_relative 'base/temp_image'
 require_relative 'base/field'
 require_relative 'base/page'
 require_relative 'base/resource'

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

@@ -9,12 +9,17 @@ module Ecoportal
             @client = client
           end
 
-          def create(commands:, &block)
-            createMutation.query(commands: commands, &block)
+          # @param register_id [String, nil] bind the new template to this register. Optional in
+          #   the schema, but in practice REQUIRED for the create to be authorized at all — see
+          #   the WHY in {Mutation::Template::Create}. Omitted when nil.
+          def create(commands:, register_id: nil, &block)
+            createMutation.query(commands: commands, register_id: register_id, &block)
           end
 
-          def update(model, commands:, patch_ver: model.patchVer, &block)
-            updateMutation.query(id: model.id, patch_ver: patch_ver, commands: commands, &block)
+          def update(model, commands:, patch_ver: model.patchVer, client_mutation_id: nil, &block)
+            kwargs = { id: model.id, patch_ver: patch_ver, commands: commands }
+            kwargs[:client_mutation_id] = client_mutation_id unless client_mutation_id.nil?
+            updateMutation.query(**kwargs, &block)
           end
 
           def publish(id:, &block)

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

@@ -18,7 +18,7 @@ module Ecoportal
         #   tag_filter      passed through (same ES backend, same format)
         #   register_filter passed through
         #   and_filter / or_filter  passed through
-        # Operation/param shapes per the repo's internal docs.
+        # Operation/param shapes per the repo's internal docs
         class FilterTranslator
           class << self
             def to_graphql(filter)

data/lib/ecoportal/api/graphql/file_upload/client.rb

@@ -26,21 +26,38 @@ module Ecoportal
         # `X-ECOPORTAL-API-KEY` is needed here: every ecoPortal call is GraphQL, on the session
         # token this client already holds.
         #
-        # Single file:
+        # ★ Extended 2026-09 with `#upload_image`/`#upload_all_images` — steps 1-2 above (the
+        # presign + S3 POST) are IDENTICAL for an Image Gallery image; only step 3 differs
+        # (`uploadImage` -> a `TempImage`, not `uploadFile` -> a `FileContainer`). Confirmed
+        # against the live ecoPortal server source (read-only, /tmp/work/ecoPortal) that an
+        # Image Gallery image is genuinely NOT a `FileContainer` — see
+        # `Mutation::Image::Upload`'s and `Base::Page::DataField::ImageGallery`'s own headers
+        # for the full evidence trail. `#presign_and_store!` is the shared internal path both
+        # `#upload_one` and `#upload_one_image` call; `#run_batch` is the shared batch-with-
+        # progress-callback loop both `#upload_all` and `#upload_all_images` call.
+        #
+        # Single file, FileContainer (File-type fields):
         #   id = api.file_upload.upload('/path/report.pdf')
         #   page.components.get_by_name('Report').file_container_ids = [id]
         #
-        # Many files, concurrently, with per-file error isolation (nothing raises out):
+        # Single file, TempImage (Image Gallery fields):
+        #   source_id = api.file_upload.upload_image('/path/photo.jpg')
+        #   page.components.get_by_name('Site Photos').add_source_images([{source_id: source_id, file_name: 'photo.jpg'}])
+        #
+        # Many files, concurrently, with per-file error isolation (nothing raises out) — same
+        # shape for both flows:
         #   results = api.file_upload.upload_all(paths, threads: 4) do |r|
         #     puts r.success? ? "#{r.file} -> #{r.container_id}" : "#{r.file} FAILED: #{r.error}"
         #   end
         #   results.select(&:error?)
         #
-        # Instrumentation / middleware — hooks fire per stage, per file:
+        # Instrumentation / middleware — hooks fire per stage, per file, for EITHER flow (the
+        # stage names are shared: `:register` fires once whether the registration mutation was
+        # `uploadFile` or `uploadImage`):
         #   client = api.file_upload
         #   client.on(:signature) { |creds|         logger.info "presigned #{creds.endpoint}" }
         #   client.on(:storage)   { |key, response| logger.info "S3 #{response.code} #{key}" }
-        #   client.on(:register)  { |payload|       logger.info "container #{payload.item&.id}" }
+        #   client.on(:register)  { |payload|       logger.info "registered #{payload.item&.id}" }
         class Client
           include Ecoportal::API::GraphQL::Concerns::Threadable
 
@@ -51,9 +68,10 @@ module Ecoportal
 
           STAGES = %i[signature storage register].freeze
           # Fallback only — the real value is a condition inside the returned policy.
-          DEFAULT_ENCRYPTION = 'AES256'.freeze
-          DEFAULT_MIME       = 'application/octet-stream'.freeze
-          MAX_THREADS        = 8
+          DEFAULT_ENCRYPTION  = 'AES256'.freeze
+          DEFAULT_MIME        = 'application/octet-stream'.freeze
+          DEFAULT_IMAGE_TYPE  = 'image_gallery'.freeze
+          MAX_THREADS         = 8
 
           # One entry per input file. Mirrors `ecoportal-api-v2`'s
           # `S3::Files::BatchUpload::FileResult` so batch code reads the same in both stacks.
@@ -77,13 +95,36 @@ module Ecoportal
             end
           end
 
+          # Sibling to {Result} for the image-upload pipeline — same shape, different item
+          # (a `TempImage`, not a `FileContainer`).
+          ImageResult = Struct.new(:file) do
+            attr_accessor :key, :payload, :error
+
+            def error?
+              !error.nil?
+            end
+
+            def success?
+              !error? && !temp_image_id.nil?
+            end
+
+            def temp_image
+              payload&.item
+            end
+
+            def temp_image_id
+              temp_image&.id
+            end
+          end
+
           def initialize(graphql_client)
             @graphql = graphql_client
             @hooks   = {}
           end
 
           # Register a stage hook. Called for every file, in that file's own thread — keep it
-          # thread-safe (or wrap it in your own mutex).
+          # thread-safe (or wrap it in your own mutex). Fires identically for {#upload} and
+          # {#upload_image} — the STAGE names are shared between both flows.
           # @param stage [:signature, :storage, :register]
           def on(stage, &block)
             stage = stage.to_sym
@@ -102,33 +143,32 @@ module Ecoportal
             result.container_id
           end
 
+          # @return [String] the new `TempImage` id (the `sourceId` an Image Gallery
+          #   `ImageInput` write needs — see `Base::Page::DataField::ImageGallery#
+          #   add_source_images`).
+          # @raise [Error] on any failure — use {#upload_all_images} for non-raising per-file
+          #   isolation.
+          def upload_image(file_path, **kargs)
+            result = upload_one_image(file_path, **kargs)
+            raise result.error if result.error?
+
+            result.temp_image_id
+          end
+
           # Uploads many files with bounded concurrency. Never raises for a single file: each
           # {Result} carries its own error, and the block is called as each finishes.
           #
           # @param threads [Integer] max concurrent uploads (`1` = inline, deterministic).
           # @return [Array<Result>] one per input file; order is not guaranteed when threaded.
           def upload_all(file_paths, threads: 4, **kargs, &block)
-            files   = Array(file_paths).flatten.compact
-            max     = threads.to_i.clamp(1, MAX_THREADS)
-            results = []
-            spawned = []
-
-            # Presign ONCE for the batch (the policy is time-boxed but reusable) and warm it
-            # here so N threads don't race for the first one.
-            credentials
-
-            with_preserved_thread_globals do
-              files.each do |file|
-                new_thread(spawned, max: max) do
-                  result = upload_one(file, **kargs)
-                  mutex(:results).synchronize { results << result }
-                  block&.call(result)
-                end
-              end
-            end
+            run_batch(file_paths, threads: threads, on_result: block) { |file| upload_one(file, **kargs) }
+          end
 
-            spawned.each(&:join)
-            results
+          # Sibling to {#upload_all} for the image-upload pipeline — identical concurrency,
+          # isolation and progress-callback semantics.
+          # @return [Array<ImageResult>]
+          def upload_all_images(file_paths, threads: 4, **kargs, &block)
+            run_batch(file_paths, threads: threads, on_result: block) { |file| upload_one_image(file, **kargs) }
           end
 
           # Force the next upload to presign again (e.g. after a policy expiry).
@@ -141,13 +181,10 @@ module Ecoportal
 
           def upload_one(file_path, location_ids: nil, tags: nil, container_id: nil)
             Result.new(file_path).tap do |result|
-              raise MissingLocalFile, "no such file: #{file_path}" unless ::File.file?(file_path)
-
-              creds      = credentials
-              result.key = storage_key(creds, file_path)
-              store!(creds, result.key, file_path)
+              _creds, key = presign_and_store!(file_path)
+              result.key     = key
               result.payload = register(
-                file_path, result.key,
+                file_path, key,
                 location_ids: location_ids, tags: tags, container_id: container_id
               )
             rescue StandardError => e
@@ -155,6 +192,61 @@ module Ecoportal
             end
           end
 
+          def upload_one_image(file_path, type: DEFAULT_IMAGE_TYPE, id: nil, import: true)
+            ImageResult.new(file_path).tap do |result|
+              _creds, key = presign_and_store!(file_path)
+              result.key     = key
+              result.payload = register_image(file_path, key, type: type, id: id, import: import)
+            rescue StandardError => e
+              result.error = e
+            end
+          end
+
+          # Shared by BOTH flows: presign (memoised per batch), build a collision-proof S3
+          # key, and the multipart POST itself. Only the THIRD step (the registration
+          # mutation — `uploadFile` vs `uploadImage`) differs between {#upload_one} and
+          # {#upload_one_image}.
+          # @return [Array(Query::FileUploadSignature::SignatureResponse, String)] the
+          #   credentials used and the S3 key the file was stored under.
+          def presign_and_store!(file_path)
+            raise MissingLocalFile, "no such file: #{file_path}" unless ::File.file?(file_path)
+
+            creds = credentials
+            key   = storage_key(creds, file_path)
+            store!(creds, key, file_path)
+            [creds, key]
+          end
+
+          # Shared by {#upload_all}/{#upload_all_images}: bounded-concurrency loop, presign-
+          # once-per-batch, per-file error isolation, and a progress callback fired as each
+          # result lands (not deferred to the end). `upload_one` (the block) is the only thing
+          # that differs between the two callers.
+          # @yieldparam file_path [String]
+          # @yieldreturn [Result, ImageResult]
+          def run_batch(file_paths, threads:, on_result: nil)
+            files   = Array(file_paths).flatten.compact
+            max     = threads.to_i.clamp(1, MAX_THREADS)
+            results = []
+            spawned = []
+
+            # Presign ONCE for the batch (the policy is time-boxed but reusable) and warm it
+            # here so N threads don't race for the first one.
+            credentials
+
+            with_preserved_thread_globals do
+              files.each do |file|
+                new_thread(spawned, max: max) do
+                  result = yield(file)
+                  mutex(:results).synchronize { results << result }
+                  on_result&.call(result)
+                end
+              end
+            end
+
+            spawned.each(&:join)
+            results
+          end
+
           # Memoised behind a mutex so a batch presigns once, not once per thread.
           def credentials
             mutex(:credentials).synchronize do
@@ -167,7 +259,8 @@ module Ecoportal
           # `uploads/<userId>/<epoch-ms>-<token>-/<basename>` — the shape the web client uses.
           # That stamp+token segment is what stops same-named files colliding: the previous
           # implementation concatenated `upload_prefix + filename`, so two uploads of
-          # `report.pdf` overwrote each other in the bucket.
+          # `report.pdf` overwrote each other in the bucket. Shared by BOTH flows — an image
+          # upload needs the identical collision-proofing.
           def storage_key(creds, file_path)
             stamp = (Time.now.to_f * 1000).to_i
             "#{creds.upload_prefix}#{stamp}-#{SecureRandom.alphanumeric(20)}-/#{::File.basename(file_path)}"
@@ -224,6 +317,18 @@ module Ecoportal
             payload
           end
 
+          def register_image(file_path, key, type:, id:, import:)
+            payload = Mutation::Image::Upload.new(@graphql.client).query(
+              key: key, type: type, id: id, import: import
+            )
+            fire(:register, payload)
+
+            raise RegistrationFailed, "uploadImage failed for #{::File.basename(file_path)}: #{payload.error_doc}" if payload.error?
+            raise RegistrationFailed, "uploadImage returned no item for #{::File.basename(file_path)}" unless payload.item&.id
+
+            payload
+          end
+
           # The bucket policy dictates the encryption header, so echo it instead of assuming:
           # the policy is base64 JSON whose `conditions` carry `x-amz-server-side-encryption`.
           def encryption(creds)

data/lib/ecoportal/api/graphql/fragment/pages/common_page_union.rb

@@ -243,11 +243,16 @@ module Ecoportal
 
             fragment imageGalleryField on ImageGallery {
               images @include(if: $content) {
+                id
+                weight
                 downloadUrl
                 caption
                 fileName
                 fileSize
-                uploadId @skip(if: $only_content)
+                uploadId                 @skip(if: $only_content)
+                sensitiveContent         @skip(if: $only_content)
+                inaccurateDescription    @skip(if: $only_content)
+                inaccurateExtractedText  @skip(if: $only_content)
               }
             }