ecoportal-api-graphql 2.2.0 → 3.0.0

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

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

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

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

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

@@ -0,0 +1,262 @@
+module Ecoportal
+  module API
+    class GraphQL
+      module Model
+        module Template
+          # Diff engine: walks the in-memory tree and emits the ordered `[CommandInput]` batch
+          # `#as_commands` returns, plus the phase-scoped subsets `StagedExecutor` sends one at
+          # a time (each subset re-synthesised against the CURRENT tree, so a node resolved by
+          # an earlier phase — `Node#resolve!` — is addressed by its real id, not its stale
+          # placeholder, the next time a phase is built; see `Node#ref`).
+          #
+          # ORDER — stage -> section -> field -> option/config -> force -> helper -> binding,
+          # matching `Diff::CommandSynthesizer::KIND_ORDER`'s own dependency-safe order plus the
+          # two groups it does not cover (force, helper/binding — no existing gem emitter
+          # before this class). Within a stage: structural section commands first
+          # (add/remove/header), THEN a `reorderSection` TRAILER for every section with a
+          # pending move (see `Section#move`'s own doc for why last) — this mirrors the
+          # EPT-2078 "preserve reorderSection trailer protection" rule.
+          #
+          # SAFETY — never guesses. A field's `field_type` has no setter (see `Field`'s own
+          # doc), so a type "change" cannot even be expressed here; every other write goes
+          # through the same `WorkflowCommand.build` layer `Builder::TemplateBuilder` and
+          # `Diff::CommandSynthesizer` already use, so a missing required key (`value` on a
+          # new option, etc.) raises there — never invented here.
+          class CommandSynthesis
+            def initialize(instance)
+              @instance = instance
+            end
+
+            # The full ordered batch — the public `#as_commands` contract.
+            def commands
+              stage_phase + section_phase + field_phase + force_phase + helper_binding_phase
+            end
+
+            # --- phase-scoped subsets, used by StagedExecutor -------------------
+
+            def stage_phase
+              instance.stages.select(&:new?).flat_map { |stage| stage_commands(stage) }
+            end
+
+            def section_phase
+              instance.stages.flat_map { |stage| section_commands_for_stage(stage) }
+            end
+
+            def field_phase
+              instance.stages.flat_map { |stage| stage.sections.flat_map { |section| field_commands_for_section(section) } }
+            end
+
+            def force_phase
+              instance.stages.flat_map { |stage|
+                stage.forces.reject(&:new?).flat_map { |f| force_edit_commands(f) } +
+                  stage.forces.select(&:new?).flat_map { |f| force_add_commands(f) }
+              }
+            end
+
+            def helper_binding_phase
+              instance.stages.flat_map { |stage| stage.forces.flat_map { |force| helper_and_binding_commands(force) } }
+            end
+
+            private
+
+            attr_reader :instance
+
+            def build(key, **kwargs)
+              Ecoportal::API::GraphQL::Input::WorkflowCommand.build(key, **kwargs)
+            end
+
+            # --- stage -----------------------------------------------------------
+
+            def stage_commands(stage)
+              [build(:addStage, name: stage.name, ordering: stage.ordering, placeholderId: stage.placeholder)]
+            end
+
+            # --- section -----------------------------------------------------------
+
+            def section_commands_for_stage(stage)
+              structural = stage.sections.flat_map { |section| section_structural_commands(stage, section) }
+              trailer    = stage.sections.reject(&:removed?).filter_map { |section| reorder_command(stage, section) }
+              structural + trailer
+            end
+
+            def section_structural_commands(stage, section)
+              return removed_section_commands(section) if section.removed?
+              return new_section_commands(stage, section) if section.new?
+
+              edited_section_commands(section)
+            end
+
+            def removed_section_commands(section)
+              [build(:removeSection, sectionId: section.id)]
+            end
+
+            def new_section_commands(stage, section)
+              cmds = [build(:addSection, placeholderId: section.placeholder, layout: section.layout)]
+              cmds << build(:addStageSection, stageId: stage.ref, sectionId: section.ref)
+              cmds << header_command(section)
+              cmds.compact
+            end
+
+            def edited_section_commands(section)
+              return [] unless section.dirty?
+
+              [header_command(section)].compact
+            end
+
+            def header_command(section)
+              changed = section.new? ? section_header_kwargs(section) : section.changed_attributes
+              return nil if changed.empty? || changed.values.all?(&:nil?)
+
+              build(:editSectionHeader, sectionId: section.ref,
+                                        header: changed[:heading], leftHeader: changed[:left_heading],
+                                        rightHeader: changed[:right_heading])
+            end
+
+            def section_header_kwargs(section)
+              { heading: section.heading, left_heading: section.left_heading, right_heading: section.right_heading }
+            end
+
+            def reorder_command(stage, section)
+              move = section.pending_move
+              return nil if move.nil?
+
+              build(:reorderSection, sectionId: section.ref, stageId: stage.ref,
+                                     anchorId: move[:anchor].ref, anchorPosition: move[:position])
+            end
+
+            # --- field / option ----------------------------------------------------
+
+            def field_commands_for_section(section)
+              section.fields.flat_map { |field| field_commands(section, field) }
+            end
+
+            def field_commands(section, field)
+              return [build(:removeField, id: field.id)] if field.removed?
+
+              cmds = field.new? ? new_field_commands(section, field) : edited_field_commands(field)
+              cmds + option_commands(field)
+            end
+
+            def new_field_commands(section, field)
+              cmds = [build(:addField, placeholderId: field.placeholder, fieldType: field.field_type,
+                                       label: field.label, stageId: field.stage.ref, sectionId: section.ref,
+                                       column: field.column)]
+              cfg = field_config_kwargs(field)
+              cmds << build(:editFieldConfiguration, data_field_id: field.ref, **stage_id_kwarg(field), **cfg) unless cfg.empty?
+              cmds
+            end
+
+            def edited_field_commands(field)
+              cfg = wire_field_config_keys(field.changed_attributes)
+              return [] if cfg.empty?
+
+              [build(:editFieldConfiguration, data_field_id: field.ref, **stage_id_kwarg(field), **cfg)]
+            end
+
+            # `editFieldConfiguration.stageId` disambiguates WHICH stage's copy of the field is
+            # being edited -- REQUIRED on a phased page (`edit_field_configuration.rb`'s own
+            # schema-authority comment), a key the schema does not need (and this class never
+            # sends, not even as an explicit `null`) on a non-phased page. `Field#stage` is
+            # ALWAYS present either way (`Read`'s workflow-first read populates it for BOTH
+            # page kinds) -- `#phased` on the owning `Instance`, not "does the field know its
+            # stage", is the real gate the schema cares about (mirrors the DSL dialect's own
+            # `Bindings.write_field_property`/the downstream `FieldWriter.configure`, both of which only
+            # thread a stage id through when one is actually known/needed).
+            def stage_id_kwarg(field)
+              field.template.phased? ? { stageId: field.stage.ref } : {}
+            end
+
+            # Only the non-nil subset of a NEW field's attributes — `editFieldConfiguration`
+            # after a fresh `addField` should not send a literal `nil` for something the
+            # caller never set. `label` is dropped: it already went through `addField`.
+            def field_config_kwargs(field)
+              wire_field_config_keys({ tooltip: field.tooltip, description: field.description,
+                                        required: field.required, hidden: field.hidden }.compact)
+            end
+
+            # `Field#hidden` (this model's read/write attribute name, matching `Read`'s own
+            # `tf` fragment key) maps onto `EditFieldConfiguration`'s real top-level argument
+            # `hideView` (`input/workflow_command/edit_field_configuration.rb`'s own
+            # `BASE_KEYS` — there is no plain `hidden` key on that input) — the one place this
+            # read/write naming split is bridged, so every other layer can stay consistent.
+            def wire_field_config_keys(cfg)
+              return cfg unless cfg.key?(:hidden)
+
+              cfg.merge(hideView: cfg[:hidden]).except(:hidden)
+            end
+
+            def option_commands(field)
+              field.options.flat_map { |opt| option_command(field, opt) }
+            end
+
+            def option_command(field, opt)
+              return [build(:removeSelectFieldOption, data_field_id: field.ref, option_id: opt.id)] if opt.removed?
+
+              if opt.new?
+                # addSelectFieldOption REQUIRES `value` (backend: AddSelectFieldOptionInput,
+                # required: true — see `Diff::CommandSynthesizer#add_option`'s own identical
+                # rule). `WorkflowCommand::AddSelectFieldOption.build` accepts a literal `nil`
+                # without complaint (it is a required KEYWORD, not a required VALUE — Ruby
+                # only enforces the keyword's presence), so this class enforces the missing-
+                # value rule itself rather than letting a `nil` reach the server.
+                if opt.value.nil?
+                  raise ArgumentError,
+                        "CommandSynthesis: cannot build addSelectFieldOption for option " \
+                        "'#{opt.label}' (field #{field.ref}) — value is nil. Set " \
+                        '`option.value = ...` before calling #as_commands/#save!.'
+                end
+
+                return [build(:addSelectFieldOption, data_field_id: field.ref, placeholderId: opt.placeholder,
+                                                      label: opt.label, value: opt.value, weight: opt.weight)]
+              end
+
+              changed = opt.changed_attributes
+              return [] if changed.empty?
+
+              [build(:editSelectFieldOption, data_field_id: field.ref, option_id: opt.id, **changed)]
+            end
+
+            # --- force / helper / binding ------------------------------------------
+
+            def force_add_commands(force)
+              [build(:addForce, placeholderId: force.placeholder, name: force.name,
+                                customScript: force.custom_script, url: force.url, contentB64: force.content_b64)]
+            end
+
+            def force_edit_commands(force)
+              changed = force.changed_attributes
+              return [] if changed.empty?
+
+              [build(:editForce, id: force.id, name: changed[:name], customScript: changed[:custom_script],
+                                 url: changed[:url], contentB64: changed[:content_b64])]
+            end
+
+            def helper_and_binding_commands(force)
+              force.helpers.select(&:new?).map { |h| helper_command(force, h) } +
+                force.bindings.flat_map { |b| binding_command(force, b) }
+            end
+
+            def helper_command(force, helper)
+              build(:addLinkedHelper, placeholderId: helper.placeholder, forceId: force.ref, name: helper.name,
+                                      filePath: helper.file_path, script: helper.script, contentB64: helper.content_b64)
+            end
+
+            def binding_command(force, binding)
+              return [] if binding.removed?
+
+              if binding.new?
+                [build(:addBinding, placeholderId: binding.placeholder, forceId: force.ref, name: binding.name,
+                                    referenceId: binding.reference_id, type: binding.type)]
+              else
+                changed = binding.changed_attributes
+                return [] if changed.empty?
+
+                [build(:editBinding, id: binding.id, name: changed[:name], referenceId: changed[:reference_id])]
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,68 @@
+module Ecoportal
+  module API
+    class GraphQL
+      module Model
+        module Template
+          # One data field. `field_type` is immutable after creation on purpose: the platform
+          # has no `editFieldType` command (confirmed,
+          # the repo's internal docs section
+          # C.1) — giving this class no setter for it makes a destructive remove+add
+          # structurally unreachable rather than a rule `#as_commands` has to remember to
+          # enforce.
+          class Field
+            include Node
+
+            PLACEHOLDER_PREFIX = 'fld'.freeze
+
+            attr_reader :template, :section, :stage, :field_type, :column, :options
+            attr_accessor :label, :tooltip, :description, :required, :hidden
+
+            def initialize(template:, section:, stage:, field_type:, id: nil, label: nil, column: nil,
+                           tooltip: nil, description: nil, required: nil, hidden: nil, options: [])
+              @template    = template
+              @section     = section
+              @stage       = stage
+              @id          = id
+              @field_type  = field_type
+              @column      = column
+              @label       = label
+              @tooltip     = tooltip
+              @description = description
+              @required    = required
+              @hidden      = hidden
+              @options     = options
+              @snapshot    = snapshot_attrs.freeze
+            end
+
+            # Appends a new (in-memory) option. Only meaningful for a Select-shaped field, but
+            # this class does not enforce `field_type` — the server does, on `addSelectFieldOption`.
+            def add_option(value:, label: nil, weight: nil)
+              opt = Option.new(template: template, field: self, label: label, value: value, weight: weight)
+              options << opt
+              opt
+            end
+
+            def dirty?
+              !removed? && !new? && snapshot_attrs != @snapshot
+            end
+
+            # The subset of `changed_attributes` that maps onto `editFieldConfiguration`'s
+            # top-level keys (label/tooltip/description/required/hidden) — empty when nothing
+            # changed, so callers can `commands << ... unless field_config_changes.empty?`.
+            def changed_attributes
+              return {} if new? || removed?
+
+              snapshot_attrs.each_with_object({}) { |(k, v), h| h[k] = v if v != @snapshot[k] }
+            end
+
+            private
+
+            def snapshot_attrs
+              { label: label, tooltip: tooltip, description: description, required: required, hidden: hidden }
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,65 @@
+module Ecoportal
+  module API
+    class GraphQL
+      module Model
+        module Template
+          # One force, owned by a Stage (`18_template_editor_save_path.md` section A.1:
+          # `TemplateStageFields.forces`). Editing an existing force is limited to
+          # name/custom_script/url/content_b64 (`editForce`'s own argument list,
+          # `input/workflow_command/edit_force.rb`) — `weight`/`lastSyncedAt` are
+          # server-managed and not exposed as writable attributes here.
+          class Force
+            include Node
+
+            PLACEHOLDER_PREFIX = 'frc'.freeze
+
+            attr_reader :template, :stage, :bindings, :helpers
+            attr_accessor :name, :custom_script, :url, :content_b64
+
+            def initialize(template:, stage:, id: nil, name: nil, custom_script: nil, url: nil, content_b64: nil)
+              @template      = template
+              @stage         = stage
+              @id            = id
+              @name          = name
+              @custom_script = custom_script
+              @url           = url
+              @content_b64   = content_b64 # rubocop:disable Naming/VariableNumber
+              @bindings      = []
+              @helpers       = []
+              @snapshot      = snapshot_attrs.freeze
+            end
+
+            def add_binding(reference_id:, name: nil, type: Binding::BINDING_TYPE)
+              binding = Binding.new(template: template, force: self, name: name, reference_id: reference_id, type: type)
+              bindings << binding
+              binding
+            end
+
+            def add_helper(name: nil, file_path: nil, script: nil, content_b64: nil)
+              helper = Helper.new(template: template, force: self, name: name, file_path: file_path,
+                                  script: script, content_b64: content_b64)
+              helpers << helper
+              helper
+            end
+
+            def dirty?
+              !removed? && !new? && snapshot_attrs != @snapshot
+            end
+
+            def changed_attributes
+              return {} if new? || removed?
+
+              snapshot_attrs.each_with_object({}) { |(k, v), h| h[k] = v if v != @snapshot[k] }
+            end
+
+            private
+
+            def snapshot_attrs
+              { name: name, custom_script: custom_script, url: url, content_b64: content_b64 }
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,32 @@
+module Ecoportal
+  module API
+    class GraphQL
+      module Model
+        module Template
+          # A force's linked helper (`addLinkedHelper`). ADD-only in this design — no live
+          # call site or schema citation for `editLinkedHelper`'s read-side shape was available
+          # to this session (see `Read.call`'s header for the read-side field-name caveat), so
+          # editing an existing helper is left unimplemented rather than guessed.
+          class Helper
+            include Node
+
+            PLACEHOLDER_PREFIX = 'hlp'.freeze
+
+            attr_reader :template, :force
+            attr_accessor :name, :file_path, :script, :content_b64
+
+            def initialize(template:, force:, id: nil, name: nil, file_path: nil, script: nil, content_b64: nil)
+              @template    = template
+              @force       = force
+              @id          = id
+              @name        = name
+              @file_path   = file_path
+              @script      = script
+              @content_b64 = content_b64 # rubocop:disable Naming/VariableNumber
+            end
+          end
+        end
+      end
+    end
+  end
+end