pvectl 0.2.0

data/lib/pvectl/services/create_container.rb

@@ -0,0 +1,179 @@
+# frozen_string_literal: true
+
+module Pvectl
+  module Services
+    # Orchestrates LXC container creation operations.
+    #
+    # Handles auto-CTID allocation, parameter building (mapping rootfs/mountpoints/net
+    # configs to Proxmox API format), sync/async modes, and optional auto-start.
+    #
+    # @example Basic container creation
+    #   service = CreateContainer.new(container_repository: ct_repo, task_repository: task_repo)
+    #   result = service.execute(hostname: "web-ct", node: "pve1",
+    #                            ostemplate: "local:vztmpl/debian-12.tar.zst",
+    #                            cores: 2, memory: 2048)
+    #
+    # @example Async creation with auto-start
+    #   service = CreateContainer.new(container_repository: ct_repo, task_repository: task_repo,
+    #                                 options: { async: true, start: true })
+    #   result = service.execute(ctid: 200, hostname: "db-ct", node: "pve1",
+    #                            ostemplate: "local:vztmpl/debian-12.tar.zst")
+    #
+    class CreateContainer
+      # @return [Integer] Default timeout for create operations (seconds)
+      DEFAULT_TIMEOUT = 300
+
+      # @return [Integer] Default timeout for start operations (seconds)
+      START_TIMEOUT = 60
+
+      # Creates a new CreateContainer service.
+      #
+      # @param container_repository [Repositories::Container] Container repository
+      # @param task_repository [Repositories::Task] Task repository
+      # @param options [Hash] Options (timeout, async, start)
+      def initialize(container_repository:, task_repository:, options: {})
+        @container_repository = container_repository
+        @task_repository = task_repository
+        @options = options
+      end
+
+      # Executes container creation operation.
+      #
+      # @param ctid [Integer, nil] Container identifier (auto-allocated if nil)
+      # @param hostname [String] Container hostname
+      # @param node [String] Target node
+      # @param ostemplate [String] OS template path
+      # @param cores [Integer, nil] Number of CPU cores
+      # @param memory [Integer, nil] Memory in MB
+      # @param swap [Integer, nil] Swap in MB
+      # @param rootfs [Hash, nil] Root filesystem config
+      # @param mountpoints [Array<Hash>, nil] Mountpoint configurations
+      # @param nets [Array<Hash>, nil] Network configurations
+      # @param privileged [Boolean, nil] Create privileged container
+      # @param features [String, nil] LXC features string
+      # @param password [String, nil] Root password
+      # @param ssh_public_keys [String, nil] SSH public keys
+      # @param onboot [Boolean, nil] Start on boot
+      # @param startup [String, nil] Startup order spec
+      # @param description [String, nil] Container description
+      # @param tags [String, nil] Tags (comma-separated)
+      # @param pool [String, nil] Resource pool
+      # @return [Models::ContainerOperationResult] Creation result
+      def execute(ctid: nil, hostname:, node:, ostemplate:, cores: nil, memory: nil,
+                  swap: nil, rootfs: nil, mountpoints: nil, nets: nil, privileged: nil,
+                  features: nil, password: nil, ssh_public_keys: nil, onboot: nil,
+                  startup: nil, description: nil, tags: nil, pool: nil)
+        ctid ||= @container_repository.next_available_ctid
+
+        params = build_params(
+          hostname: hostname, ostemplate: ostemplate, cores: cores, memory: memory,
+          swap: swap, rootfs: rootfs, mountpoints: mountpoints, nets: nets,
+          privileged: privileged, features: features, password: password,
+          ssh_public_keys: ssh_public_keys, onboot: onboot, startup: startup,
+          description: description, tags: tags, pool: pool
+        )
+
+        upid = @container_repository.create(node, ctid, params)
+        resource_info = { ctid: ctid, hostname: hostname, node: node }
+
+        if @options[:async]
+          build_result(resource_info, task_upid: upid, success: :pending)
+        else
+          task = @task_repository.wait(upid, timeout: timeout)
+          start_container(ctid, node) if task.successful? && @options[:start]
+          build_result(resource_info, task: task, success: task.successful?)
+        end
+      rescue StandardError => e
+        build_result({ ctid: ctid, hostname: hostname, node: node },
+                     success: false, error: e.message)
+      end
+
+      private
+
+      # Builds Proxmox API parameters from user-friendly options.
+      #
+      # Maps rootfs/mountpoint configs through {Parsers::LxcMountConfig.to_proxmox} and
+      # network configs through {Parsers::LxcNetConfig.to_proxmox}.
+      #
+      # @return [Hash] Proxmox API parameters
+      def build_params(hostname:, ostemplate:, cores:, memory:, swap:, rootfs:,
+                       mountpoints:, nets:, privileged:, features:, password:,
+                       ssh_public_keys:, onboot:, startup:, description:, tags:, pool:)
+        params = { hostname: hostname, ostemplate: ostemplate }
+        params[:cores] = cores if cores
+        params[:memory] = memory if memory
+        params[:swap] = swap if swap
+        params[:unprivileged] = privileged ? 0 : 1 unless privileged.nil?
+        params[:rootfs] = Parsers::LxcMountConfig.to_proxmox(rootfs) if rootfs
+        add_mountpoint_params(params, mountpoints) if mountpoints
+        add_net_params(params, nets) if nets
+        params[:features] = features if features
+        params[:password] = password if password
+        params[:"ssh-public-keys"] = ssh_public_keys if ssh_public_keys
+        params[:onboot] = onboot ? 1 : 0 unless onboot.nil?
+        params[:startup] = startup if startup
+        params[:description] = description if description
+        params[:tags] = tags if tags
+        params[:pool] = pool if pool
+        params
+      end
+
+      # Adds mountpoint parameters mapped to mp0, mp1, etc.
+      #
+      # @param params [Hash] Parameters hash to modify
+      # @param mountpoints [Array<Hash>] Mountpoint configurations
+      # @return [void]
+      def add_mountpoint_params(params, mountpoints)
+        mountpoints.each_with_index do |mp, index|
+          params[:"mp#{index}"] = Parsers::LxcMountConfig.to_proxmox(mp)
+        end
+      end
+
+      # Adds network parameters mapped to net0, net1, etc.
+      #
+      # @param params [Hash] Parameters hash to modify
+      # @param nets [Array<Hash>] Network configurations
+      # @return [void]
+      def add_net_params(params, nets)
+        nets.each_with_index do |net, index|
+          params[:"net#{index}"] = Parsers::LxcNetConfig.to_proxmox(net)
+        end
+      end
+
+      # Starts a container after successful creation.
+      #
+      # @param ctid [Integer] Container identifier
+      # @param node [String] Node name
+      # @return [void]
+      def start_container(ctid, node)
+        upid = @container_repository.start(ctid, node)
+        @task_repository.wait(upid, timeout: START_TIMEOUT)
+      end
+
+      # Returns configured timeout.
+      #
+      # @return [Integer] Timeout in seconds
+      def timeout
+        @options[:timeout] || DEFAULT_TIMEOUT
+      end
+
+      # Builds a ContainerOperationResult with the :create operation.
+      #
+      # Creates a minimal Container model for presenter compatibility.
+      #
+      # @param resource_info [Hash] Resource info (ctid, hostname, node)
+      # @param attrs [Hash] Additional result attributes
+      # @return [Models::ContainerOperationResult] Operation result
+      def build_result(resource_info, **attrs)
+        container = Models::Container.new(
+          vmid: resource_info[:ctid],
+          name: resource_info[:hostname],
+          node: resource_info[:node]
+        )
+        Models::ContainerOperationResult.new(
+          operation: :create, container: container, resource: resource_info, **attrs
+        )
+      end
+    end
+  end
+end

data/lib/pvectl/services/create_vm.rb

@@ -0,0 +1,191 @@
+# frozen_string_literal: true
+
+module Pvectl
+  module Services
+    # Orchestrates VM creation operations.
+    #
+    # Handles auto-VMID allocation, parameter building (mapping disk/net/cloud-init
+    # configs to Proxmox API format), sync/async modes, and optional auto-start.
+    #
+    # @example Basic VM creation
+    #   service = CreateVm.new(vm_repository: vm_repo, task_repository: task_repo)
+    #   result = service.execute(name: "web-server", node: "pve1",
+    #                            cores: 4, memory: 4096,
+    #                            disks: [{ storage: "local-lvm", size: "32G" }])
+    #
+    # @example Async creation with auto-start
+    #   service = CreateVm.new(vm_repository: vm_repo, task_repository: task_repo,
+    #                          options: { async: true, start: true })
+    #   result = service.execute(vmid: 200, name: "db-server", node: "pve1",
+    #                            cores: 8, memory: 16384)
+    #
+    class CreateVm
+      # @return [Integer] Default timeout for create operations (seconds)
+      DEFAULT_TIMEOUT = 300
+
+      # @return [Integer] Default timeout for start operations (seconds)
+      START_TIMEOUT = 60
+
+      # Creates a new CreateVm service.
+      #
+      # @param vm_repository [Repositories::Vm] VM repository
+      # @param task_repository [Repositories::Task] Task repository
+      # @param options [Hash] Options (timeout, async, start)
+      def initialize(vm_repository:, task_repository:, options: {})
+        @vm_repository = vm_repository
+        @task_repository = task_repository
+        @options = options
+      end
+
+      # Executes VM creation operation.
+      #
+      # @param vmid [Integer, nil] VM identifier (auto-allocated if nil)
+      # @param name [String] VM name
+      # @param node [String] Target node
+      # @param cores [Integer, nil] Number of CPU cores
+      # @param sockets [Integer, nil] Number of CPU sockets
+      # @param cpu_type [String, nil] CPU type (e.g. "host", "kvm64")
+      # @param numa [Boolean, nil] Enable NUMA
+      # @param memory [Integer, nil] Memory in MB
+      # @param balloon [Integer, nil] Balloon memory in MB
+      # @param disks [Array<Hash>, nil] Disk configurations
+      # @param scsihw [String, nil] SCSI controller type
+      # @param cdrom [String, nil] CD-ROM ISO path
+      # @param nets [Array<Hash>, nil] Network configurations
+      # @param bios [String, nil] BIOS type (seabios or ovmf)
+      # @param boot_order [String, nil] Boot order (e.g. "scsi0;net0")
+      # @param machine [String, nil] Machine type (e.g. "q35")
+      # @param efidisk [String, nil] EFI disk specification
+      # @param cloud_init [Hash, nil] Cloud-init parameters
+      # @param agent [Boolean, nil] Enable QEMU guest agent
+      # @param ostype [String, nil] OS type (e.g. "l26", "win10")
+      # @param description [String, nil] VM description
+      # @param tags [String, nil] Tags (semicolon-separated)
+      # @param pool [String, nil] Resource pool
+      # @return [Models::VmOperationResult] Creation result
+      def execute(vmid: nil, name:, node:, cores: nil, sockets: nil, cpu_type: nil,
+                  numa: nil, memory: nil, balloon: nil, disks: nil, scsihw: nil,
+                  cdrom: nil, nets: nil, bios: nil, boot_order: nil, machine: nil,
+                  efidisk: nil, cloud_init: nil, agent: nil, ostype: nil,
+                  description: nil, tags: nil, pool: nil)
+        vmid ||= @vm_repository.next_available_vmid
+
+        params = build_params(
+          name: name, cores: cores, sockets: sockets, cpu_type: cpu_type,
+          numa: numa, memory: memory, balloon: balloon, disks: disks,
+          scsihw: scsihw, cdrom: cdrom, nets: nets, bios: bios,
+          boot_order: boot_order, machine: machine, efidisk: efidisk,
+          cloud_init: cloud_init, agent: agent, ostype: ostype,
+          description: description, tags: tags, pool: pool
+        )
+
+        upid = @vm_repository.create(node, vmid, params)
+        resource_info = { vmid: vmid, name: name, node: node }
+
+        if @options[:async]
+          build_result(resource_info, task_upid: upid, success: :pending)
+        else
+          task = @task_repository.wait(upid, timeout: timeout)
+          start_vm(vmid, node) if task.successful? && @options[:start]
+          build_result(resource_info, task: task, success: task.successful?)
+        end
+      rescue StandardError => e
+        build_result({ vmid: vmid, name: name, node: node },
+                     success: false, error: e.message)
+      end
+
+      private
+
+      # Builds Proxmox API parameters from user-friendly options.
+      #
+      # Maps disk configs through {Parsers::DiskConfig.to_proxmox} and
+      # network configs through {Parsers::NetConfig.to_proxmox}.
+      #
+      # @return [Hash] Proxmox API parameters
+      def build_params(name:, cores:, sockets:, cpu_type:, numa:, memory:,
+                       balloon:, disks:, scsihw:, cdrom:, nets:, bios:,
+                       boot_order:, machine:, efidisk:, cloud_init:, agent:,
+                       ostype:, description:, tags:, pool:)
+        params = { name: name }
+        params[:cores] = cores if cores
+        params[:sockets] = sockets if sockets
+        params[:cpu] = cpu_type if cpu_type
+        params[:numa] = numa ? 1 : 0 unless numa.nil?
+        params[:memory] = memory if memory
+        params[:balloon] = balloon if balloon
+        add_disk_params(params, disks) if disks
+        params[:scsihw] = scsihw if scsihw
+        params[:cdrom] = cdrom if cdrom
+        add_net_params(params, nets) if nets
+        params[:bios] = bios if bios
+        params[:boot] = "order=#{boot_order}" if boot_order
+        params[:machine] = machine if machine
+        params[:efidisk0] = efidisk if efidisk
+        params.merge!(cloud_init) if cloud_init
+        params[:agent] = agent ? "1" : "0" unless agent.nil?
+        params[:ostype] = ostype if ostype
+        params[:description] = description if description
+        params[:tags] = tags if tags
+        params[:pool] = pool if pool
+        params
+      end
+
+      # Adds disk parameters mapped to scsi0, scsi1, etc.
+      #
+      # @param params [Hash] Parameters hash to modify
+      # @param disks [Array<Hash>] Disk configurations
+      # @return [void]
+      def add_disk_params(params, disks)
+        disks.each_with_index do |disk, index|
+          params[:"scsi#{index}"] = Parsers::DiskConfig.to_proxmox(disk)
+        end
+      end
+
+      # Adds network parameters mapped to net0, net1, etc.
+      #
+      # @param params [Hash] Parameters hash to modify
+      # @param nets [Array<Hash>] Network configurations
+      # @return [void]
+      def add_net_params(params, nets)
+        nets.each_with_index do |net, index|
+          params[:"net#{index}"] = Parsers::NetConfig.to_proxmox(net)
+        end
+      end
+
+      # Starts a VM after successful creation.
+      #
+      # @param vmid [Integer] VM identifier
+      # @param node [String] Node name
+      # @return [void]
+      def start_vm(vmid, node)
+        upid = @vm_repository.start(vmid, node)
+        @task_repository.wait(upid, timeout: START_TIMEOUT)
+      end
+
+      # Returns configured timeout.
+      #
+      # @return [Integer] Timeout in seconds
+      def timeout
+        @options[:timeout] || DEFAULT_TIMEOUT
+      end
+
+      # Builds a VmOperationResult with the :create operation.
+      #
+      # Creates a minimal Vm model for presenter compatibility.
+      #
+      # @param resource_info [Hash] Resource info (vmid, name, node)
+      # @param attrs [Hash] Additional result attributes
+      # @return [Models::VmOperationResult] Operation result
+      def build_result(resource_info, **attrs)
+        vm = Models::Vm.new(
+          vmid: resource_info[:vmid],
+          name: resource_info[:name],
+          node: resource_info[:node]
+        )
+        Models::VmOperationResult.new(
+          operation: :create, vm: vm, resource: resource_info, **attrs
+        )
+      end
+    end
+  end
+end

data/lib/pvectl/services/edit_container.rb

@@ -0,0 +1,125 @@
+# frozen_string_literal: true
+
+module Pvectl
+  module Services
+    # Orchestrates the interactive container configuration editing flow.
+    #
+    # Fetches current config, opens it in an editor as structured YAML,
+    # validates changes, computes a diff, and applies updates via the API.
+    # Supports dry-run mode and optimistic locking via digest.
+    #
+    # @example Basic usage
+    #   service = EditContainer.new(container_repository: repo)
+    #   result = service.execute(ctid: 200)
+    #
+    # @example Dry run with injected editor session
+    #   service = EditContainer.new(container_repository: repo, editor_session: session,
+    #                               options: { dry_run: true })
+    #   result = service.execute(ctid: 200)
+    #
+    class EditContainer
+      # Creates a new EditContainer service.
+      #
+      # @param container_repository [Repositories::Container] Container repository
+      # @param editor_session [EditorSession, nil] optional injected editor session
+      # @param options [Hash] options (dry_run)
+      def initialize(container_repository:, editor_session: nil, options: {})
+        @container_repository = container_repository
+        @editor_session = editor_session
+        @options = options
+      end
+
+      # Executes the interactive container edit flow.
+      #
+      # @param ctid [Integer] Container identifier
+      # @return [Models::ContainerOperationResult, nil] operation result, or nil if cancelled/no changes
+      def execute(ctid:)
+        container = @container_repository.get(ctid)
+        return not_found_result(ctid) unless container
+
+        config = @container_repository.fetch_config(container.node, ctid)
+        resource_info = { ctid: ctid, node: container.node, status: container.status }
+
+        yaml_content = ConfigSerializer.to_yaml(config, type: :container, resource: resource_info)
+
+        validator = ->(content) { ConfigSerializer.validate(content, type: :container) }
+        session = @editor_session || EditorSession.new(validator: validator)
+        edited = session.edit(yaml_content)
+
+        return nil unless edited
+
+        original_roundtrip = ConfigSerializer.from_yaml(yaml_content, type: :container)
+        edited_flat = ConfigSerializer.from_yaml(edited, type: :container)
+
+        violations = ConfigSerializer.readonly_violations(original_roundtrip, edited_flat, type: :container)
+        unless violations.empty?
+          return build_result(resource_info, success: false,
+                              error: "Read-only fields cannot be changed: #{violations.join(', ')}")
+        end
+
+        changes = ConfigSerializer.diff(original_roundtrip, edited_flat)
+
+        if changes[:changed].empty? && changes[:added].empty? && changes[:removed].empty?
+          return nil
+        end
+
+        params = build_update_params(changes, config)
+
+        resource_info[:diff] = changes
+
+        if @options[:dry_run]
+          return build_result(resource_info, success: true)
+        end
+
+        @container_repository.update(ctid, container.node, params)
+        build_result(resource_info, success: true)
+      rescue StandardError => e
+        build_result({ ctid: ctid }, success: false, error: e.message)
+      end
+
+      private
+
+      # Builds API update parameters from a diff hash.
+      #
+      # Maps changed/added keys to their new values, removed keys to the
+      # Proxmox `delete` parameter, and includes digest for optimistic locking.
+      #
+      # @param changes [Hash] diff hash with :changed, :added, :removed
+      # @param original_config [Hash] original flat config (for digest)
+      # @return [Hash] Proxmox API parameters
+      def build_update_params(changes, original_config)
+        params = {}
+        changes[:changed].each { |key, (_old, new_val)| params[key] = new_val }
+        changes[:added].each { |key, val| params[key] = val }
+        unless changes[:removed].empty?
+          params[:delete] = changes[:removed].map(&:to_s).join(",")
+        end
+        params[:digest] = original_config[:digest] if original_config[:digest]
+        params
+      end
+
+      # Builds a ContainerOperationResult with the :edit operation.
+      #
+      # @param resource_info [Hash] resource info (ctid, node, status)
+      # @param attrs [Hash] additional result attributes
+      # @return [Models::ContainerOperationResult]
+      def build_result(resource_info, **attrs)
+        container = Models::Container.new(
+          vmid: resource_info[:ctid],
+          node: resource_info[:node]
+        )
+        Models::ContainerOperationResult.new(
+          operation: :edit, container: container, resource: resource_info, **attrs
+        )
+      end
+
+      # Builds a not-found error result.
+      #
+      # @param ctid [Integer] Container identifier
+      # @return [Models::ContainerOperationResult]
+      def not_found_result(ctid)
+        build_result({ ctid: ctid }, success: false, error: "Container #{ctid} not found")
+      end
+    end
+  end
+end

data/lib/pvectl/services/edit_dns.rb

@@ -0,0 +1,159 @@
+# frozen_string_literal: true
+
+module Pvectl
+  module Services
+    # Orchestrates the interactive editing flow for node DNS settings.
+    #
+    # Fetches current DNS config, presents it as YAML in an editor, computes
+    # a diff, and applies changes via the Proxmox API. The Proxmox PUT endpoint
+    # requires the `search` field — the service validates this before calling.
+    #
+    # @example Basic usage
+    #   service = EditDns.new(dns_repository: repo)
+    #   result = service.execute(node_name: "pve1")
+    #
+    # @example Dry run
+    #   service = EditDns.new(dns_repository: repo, options: { dry_run: true })
+    #   result = service.execute(node_name: "pve1")
+    #
+    class EditDns
+      # Editable keys exposed in the YAML editor (in order).
+      EDITABLE_KEYS = %i[search dns1 dns2 dns3].freeze
+
+      # Creates a new EditDns service.
+      #
+      # @param dns_repository [Repositories::Dns] DNS repository
+      # @param editor_session [EditorSession, nil] optional injected editor session
+      # @param options [Hash] options (dry_run)
+      def initialize(dns_repository:, editor_session: nil, options: {})
+        @dns_repository = dns_repository
+        @editor_session = editor_session
+        @options = options
+      end
+
+      # Executes the interactive DNS edit flow.
+      #
+      # @param node_name [String] node name
+      # @return [Models::NodeOperationResult, nil] result, or nil if cancelled/no changes
+      def execute(node_name:)
+        dns = @dns_repository.fetch(node_name)
+        resource_info = { node_name: node_name }
+
+        editable = build_editable(dns)
+        yaml_content = "# Node: #{node_name} — DNS configuration\n" \
+                       "# 'search' is required by Proxmox. dns1/dns2/dns3 are optional.\n" +
+                       editable.to_yaml
+
+        session = @editor_session || EditorSession.new
+        edited = session.edit(yaml_content)
+
+        return nil unless edited
+
+        cleaned = edited.lines.reject { |l| l.strip.start_with?("#") }.join
+        edited_config = YAML.safe_load(cleaned, symbolize_names: true) || {}
+
+        original_symbolized = editable.transform_keys(&:to_sym)
+        changes = compute_diff(original_symbolized, edited_config)
+
+        if changes[:changed].empty? && changes[:added].empty? && changes[:removed].empty?
+          return nil
+        end
+
+        validate!(edited_config)
+
+        resource_info[:diff] = changes
+
+        return build_result(resource_info, success: true) if @options[:dry_run]
+
+        @dns_repository.update(node_name, build_update_params(edited_config))
+        build_result(resource_info, success: true)
+      rescue StandardError => e
+        build_result({ node_name: node_name }, success: false, error: e.message)
+      end
+
+      private
+
+      # Builds editable hash (string-keyed) from a DnsConfig model.
+      #
+      # @param dns [Models::DnsConfig] current config
+      # @return [Hash{String=>String}] editable values
+      def build_editable(dns)
+        {
+          "search" => dns.search,
+          "dns1" => dns.dns1,
+          "dns2" => dns.dns2,
+          "dns3" => dns.dns3
+        }.compact
+      end
+
+      # Validates the edited config satisfies API requirements.
+      #
+      # @param edited [Hash] edited config with symbol keys
+      # @return [void]
+      # @raise [ArgumentError] if `search` is missing or empty
+      def validate!(edited)
+        search = edited[:search]
+        if search.nil? || search.to_s.strip.empty?
+          raise ArgumentError, "search field is required by Proxmox API"
+        end
+      end
+
+      # Computes diff between original and edited configs.
+      #
+      # @param original [Hash] original config (symbol keys)
+      # @param edited [Hash] edited config (symbol keys)
+      # @return [Hash] diff with :changed, :added, :removed
+      def compute_diff(original, edited)
+        changed = {}
+        added = {}
+        removed = []
+
+        edited.each do |key, value|
+          orig_value = original[key]
+          if orig_value.nil?
+            added[key] = value
+          elsif orig_value.to_s != value.to_s
+            changed[key] = [orig_value.to_s, value.to_s]
+          end
+        end
+
+        original.each_key do |key|
+          removed << key unless edited.key?(key)
+        end
+
+        { changed: changed, added: added, removed: removed }
+      end
+
+      # Builds API update parameters from edited config.
+      #
+      # The PUT endpoint requires `search` and accepts optional dns1-3.
+      # Removed keys are sent as empty strings to clear the field
+      # (Proxmox accepts empty strings as "unset" for optional dns* fields).
+      #
+      # @param edited [Hash] edited config (symbol keys)
+      # @return [Hash] API parameters with all editable keys present
+      def build_update_params(edited)
+        params = {}
+        EDITABLE_KEYS.each do |key|
+          value = edited[key]
+          params[key] = value.nil? ? "" : value
+        end
+        # search must always have a real value (validated above)
+        params[:search] = edited[:search]
+        params
+      end
+
+      # Builds a NodeOperationResult with the :edit operation.
+      #
+      # @param resource_info [Hash] resource info (node_name)
+      # @param attrs [Hash] additional result attributes
+      # @return [Models::NodeOperationResult]
+      def build_result(resource_info, **attrs)
+        node_model = Models::Node.new(name: resource_info[:node_name])
+        Models::NodeOperationResult.new(
+          operation: :edit, node_model: node_model, resource: resource_info, **attrs
+        )
+      end
+    end
+  end
+end