eco-helpers 3.2.2 → 3.2.4

data/lib/eco/api/usecases/graphql/helpers/location/command/results.rb

@@ -1,63 +1,138 @@
 module Eco::API::UseCases::GraphQL::Helpers::Location::Command
+  # Final ressults of the full run.
   class Results
-    attr_reader :input, :response
+    attr_accessor :draft
+    attr_accessor :target_tree
 
-    def initialize(input, response)
-      @input    = input
-      @response = response
+    def initialize(target_tree)
+      @target_tree = target_tree
     end
 
-    def stats
-      msg       = ''
-      msg << "  * Errored: #{errored.count} #{first_err_str}\n" if errored?
-      msg << "  * Applied: #{errored.count} #{last_okay_str}\n" if some_applied?
-      msg << "  * Pending: #{pending.count}\n"                  if some_pending?
-      msg
+    def draft_id
+      draft&.id
     end
 
-    # Was this configured to force-continue on command error?
-    def force?
-      input[:force]
+    def parent_structure
+      draft&.parent_structure || target_tree
     end
 
-    # # Offers a summary. If anything went wrong, it's `false`.
-    # # If everything went right, it's `true`.
-    # def ok?
-    #   response&.ok
-    # end
+    # @note target parent structure id
+    def structure_id
+      parent_structure&.id
+    end
 
-    # Overal errors (i.e. ID clashes between different structures)
-    def error
-      response&.error
+    # @note the result of the draft
+    def structure
+      draft&.structure
     end
 
+    # @note it receives the final `results` response (when the draft gets published)
+    def final_response(response = nil)
+      return @response if response.nil?
+
+      @response = response
+    end
+
+    def final_response?
+      !final_response.nil?
+    end
+
+    # @note it only accounts for the errors of the final publishing of the draft.
     def error?
-      !!error
+      return false unless final_response
+
+      final_response.error?
     end
 
     def success?
-      !error? && results.all?(&:success?)
+      !error?
+    end
+
+    def applied_commands(with_id_change: false)
+      results.select(&:applied?).then do |applied|
+        next applied unless with_id_change
+
+        applied.select do |result|
+          next false unless (command = result.command_result_data)
+
+          command.keys.include?(:newId)
+        end
+      end
     end
 
     def results
-      @results ||= input_commands.zip(response_results).each_with_object([]) do |(i, r), results|
+      return [] unless final_response
+
+      @results ||= input_commands.zip(command_results).each_with_object([]) do |(i, r), results|
         results << Result.new(i, r)
       end
     end
 
+    # @note this captures the latest draft
+    def add_response(key, input_unit_response)
+      self[key] << input_unit_response
+      input_unit_response.tap do |iur|
+        next if final_response
+
+        self.draft = iur.draft
+      end
+    end
+
+    def[](key)
+      responses[key] ||= []
+    end
+
+    def responses
+      @responses ||= {}
+    end
+
+    def keys
+      responses.keys
+    end
+
     def count
-      results.count
+      responses.values.flatten.count
+    end
+
+    def input_commands
+      keys.each_with_object([]) do |key, commands|
+        self[key].each do |input|
+          next unless input.is_a?(InputUnitResponse)
+
+          commands.concat(input.commands)
+        end
+      end
     end
 
-    def input_result(input)
-      results_by_input[input]
+    def command_results(response = final_response)
+      response = final_response(response)
+      return [] unless response
+
+      response.results || []
+    end
+
+    def stats
+      msg       = ''
+      msg << "  * Errored: #{errored.count} #{first_err_str}\n" if errored?
+      msg << "  * Applied: #{applied.count} #{last_okay_str}\n" if some_applied?
+      msg << "  * Pending: #{pending.count}\n"                  if some_pending?
+      msg
     end
 
-    def input_idx(input)
-      results.index(input_result(input))
+    # Overal errors (i.e. ID clashes between different structures)
+    def error
+      response&.error
     end
 
-    def idx(result)
+    # def input_result(input)
+    #   results_by_input[input]
+    # end
+
+    # def input_idx(input)
+    #   results.index(input_result(input))
+    # end
+
+    def result_idx(result)
       results.index(result)
     end
 
@@ -65,28 +140,32 @@ module Eco::API::UseCases::GraphQL::Helpers::Location::Command
       @errored ||= results.select(&:error?)
     end
 
+    def applied
+      @applied ||= results.select(&:applied?)
+    end
+
+    def pending
+      @pending ||= results.select(&:pending?)
+    end
+
     def errored?
       errored.any?
     end
 
+    def applied?
+      results.all?(&:applied?)
+    end
+
     def first_errored
       errored.first
     end
 
     def first_errored_idx
-      idx(first_errored)
-    end
-
-    def applied
-      @applied ||= results.select(&:applied?)
-    end
-
-    def applied?
-      results.all?(&:applied?)
+      result_idx(first_errored)
     end
 
     def some_applied?
-      applied.count.positive?
+      applied.any?
     end
 
     def last_applied
@@ -94,11 +173,7 @@ module Eco::API::UseCases::GraphQL::Helpers::Location::Command
     end
 
     def last_applied_idx
-      idx(last_applied)
-    end
-
-    def pending
-      @pending ||= results.select(&:pending?)
+      result_idx(last_applied)
     end
 
     def some_pending?
@@ -107,34 +182,21 @@ module Eco::API::UseCases::GraphQL::Helpers::Location::Command
 
     private
 
-    def results_by_input
-      @results_by_input ||= results.each_with_object({}) do |r, h|
-        h[r.input] = r
-      end
-    end
-
-    def input_commands
-      input[:commands]
-    end
-
-    def response_results
-      response&.results || []
-    end
+    # def results_by_input
+    #   @results_by_input ||= results.each_with_object({}) do |res, h|
+    #     h[res.input] = res
+    #   end
+    # end
 
     # First error is relevant only if request was NOT forced to continue.
     def first_err_str
-      return '' if force?
-
-      pre_str = 'stopped on node'
-      pre_str = 'first error' unless force?
+      pre_str = 'first error'
 
       "(#{pre_str}: '#{first_errored&.node_id}' - idx: #{first_errored_idx})"
     end
 
     # Last successfully applied is relevant only if request was NOT forced to continue.
     def last_okay_str
-      return '' if force?
-
       "(last node done: '#{last_applied&.node_id}' - idx: #{last_applied_idx})"
     end
   end

data/lib/eco/api/usecases/graphql/helpers/location/command.rb

@@ -3,32 +3,15 @@ module Eco::API::UseCases::GraphQL::Helpers::Location
     include Eco::Language::AuxiliarLogger
     include Eco::API::UseCases::GraphQL::Helpers::Location::Base
 
-    require_relative 'command/optimizations'
-    include Eco::API::UseCases::GraphQL::Helpers::Location::Command::Optimizations
+    require_relative 'command/end_points'
+    include Eco::API::UseCases::GraphQL::Helpers::Location::Command::EndPoints
 
-    # Actual GraphQL request
-    def apply_commands(input, &block)
-      graphql.locationStructure.applyCommands(input: input, &block)
-    end
-
-    # With given the commands, it generates the input of the endpoint mutation.
-    # @param commands [Array<Hash>]
-    def input(commands, force_continue: force_continue?)
-      {
-        clientMutationId: '',
-        id:               target_structure_id,
-        force:            force_continue,
-        commands:         commands
-      }
-    end
-
-    # @param track_tree_mode [Symbol] when should updates happen
+    # @note it does the API call.
     # @return see #with_sliced_input
     def sliced_batches(
       batch_input,
-      size:            commands_per_page,
-      desc:            :input,
-      track_tree_mode: default_tree_tracking_mode
+      size: commands_per_page,
+      desc: :input
     )
       dry_run_msg = simulate? ? '(dry-run) ' : ''
 
@@ -46,19 +29,29 @@ module Eco::API::UseCases::GraphQL::Helpers::Location
         msg << "with #{count} commands (done #{done} of #{total})..."
         log(:info) { msg }
 
-        response = nil
         unless simulate? && !options.dig(:requests, :backup)
-          backup(sliced_input, type: "tree_update_#{desc}_request_#{page}_of_#{pages}")
+          watermark = "tree_update_#{desc}_response_#{page}_of_#{pages}"
+
+          backup(sliced_input, type: watermark)
         end
 
-        if simulate?
-          log(:info) { sliced_input.pretty_inspect } if page < 3
-        else
-          curr_block = scope_commands_block(page, pages, track_tree_mode: track_tree_mode)
-          response   = apply_commands(sliced_input, &curr_block)
-          backup(response, type: "tree_update_#{desc}_response_#{page}_of_#{pages}")
+        if simulate? && page < 3
+          log(:info) {
+            JSON.pretty_generate(sliced_input)
+          }
         end
 
+        # fetch structure? (by using default, when curr_block == nil)
+        # We should only fetch at the very end (last standard stage)
+        #   - We will explicitly fetch the draft structure before re-archive.
+        response = add_commands(
+          sliced_input,
+          &commands_payload_without_structure_block
+        )
+
+        watermark = "tree_update_#{desc}_response_#{page}_of_#{pages}"
+        backup(response, type: watermark) unless simulate?
+
         done += count
         yield(sliced_input, response, page, pages, done, total) if block_given?
       end
@@ -88,6 +81,7 @@ module Eco::API::UseCases::GraphQL::Helpers::Location
 end
 
 require_relative 'command/result'
+require_relative 'command/input_unit_response'
 require_relative 'command/results'
 require_relative 'command/diff'
 require_relative 'command/diffs'

data/lib/eco/api/usecases/graphql/samples/location/command/dsl.rb

@@ -1,9 +1,32 @@
 class Eco::API::UseCases::GraphQL::Samples::Location
   module Command::DSL
+    include Eco::API::UseCases::GraphQL::Samples::Location::Service::TreeDiff
     include Eco::API::UseCases::GraphQL::Helpers::Location::Command
     include Eco::API::UseCases::GraphQL::Samples::Location::Command::TrackChangedIds
     include Eco::API::UseCases::GraphQL::Samples::Location::Command::Results
 
+    def print_diff_details?
+      false
+    end
+
+    # With given the commands, it generates the input of the endpoint mutation.
+    # @param commands [Array<Hash>]
+    def input(commands, force_continue: force_continue?)
+      return unless (commands || []).any?
+
+      results.draft ||= create_draft(
+        current_tree.id,
+        &create_payload_without_structure_block
+      ).draft
+
+      {
+        clientMutationId: '',
+        id:               results.draft_id,
+        commands:         commands
+      }
+    end
+
+    # @note this method should be overriden/re-implemented
     # @example of implementation:
     #     def inputs(command_types, force_continue: force_continue?)
     #       {}.tap do |sequence|
@@ -16,65 +39,207 @@ class Eco::API::UseCases::GraphQL::Samples::Location
     #         end
     #       end
     #     end
-    def inputs(*_args, force_continue: force_continue?, **_kargs, &_block) # rubocop:disable Lint/UnusedMethodArgument
-      msg  = "You should implement this method in your child class.\n"
-      msg << 'Which should yield the input Hash and the stage or descriptor.'
-      raise Eco::API::UseCases::GraphQL::Base::NotImplementedMethod, msg
+    def inputs(nodes_diff = comparer, force_continue: force_continue?)
+      {}.tap do |sequence|
+        unless nodes_diff && nodes_diff.respond_to?(:commands)
+          msg  = "You should implement this method in your child class.\n"
+          msg << "Which should yield the input Hash and the stage or descriptor.\n"
+          msg << "Or you should provide the `nodes_diff` object."
+          raise Eco::API::UseCases::GraphQL::Base::NotImplementedMethod, msg
+        end
+
+        nodes_diff.commands do |comms, stage|
+          sequence[stage] = input(comms, force_continue: force_continue)
+        end
+      end.tap do |sequence|
+        sequence.each do |stage, input|
+          yield(input, stage) if block_given?
+        end
+      end
     end
 
-    # Main processor
-    def process # rubocop:disable Metrics/AbcSize
-      self.error = false
+    # MAIN PROCESSOR
+    def process
+      self.error  = false
+      some_update = false
 
       with_error_handling do
         super if defined?(super)
 
-        # this may trigger a backup of the tagtree
+        # The very first track of the current structure.
+        #   - This may trigger a backup of the tagtree.
         self.current_tree ||= live_tree
+        results(current_tree)
 
-        inputs(force_continue: force_continue?) do |input, stage|
-          results[stage] ||= []
+        inputs(
+          force_continue: force_continue?
+        ) do |input, stage|
+          next unless input
 
-          track_mode = batch_tree_track_mode(stage)
+          some_update = true
 
-          # yields the result of each batch
-          sliced_batches(input, desc: stage, track_tree_mode: track_mode) do |sliced_input, response, page, pages, done, total| # rubocop:disable Metrics/ParameterLists, Layout/LineLength
-            track_current_tree(response&.structure)
+          sliced_batches(
+            input,
+            desc: stage,
+            &results_tracking_block(stage: stage)
+          )
 
-            results[stage] << (page_results = request_results_class.new(sliced_input, response))
-            update_tags_remap_table(page_results, stage, current_tree)
-
-            self.error = page_errors?(page_results, page, pages, done, total, stage: stage)
-            break if error
-          end
-
-          break if error
+          break if error?
         rescue StandardError => err
           log(:error) { err.patch_full_message }
           raise
         end
       end
     ensure
-      rescued { self.tags_remap_csv_file = generate_tags_remap_csv }
-      rescued { close_handling_tags_remap_csv }
+      rescued do
+        next if exception
+
+        refetch_draft if some_update
+        rearchive
+      end
+
+      rescued { delete_or_publish_draft }
+      rescued { manage_remaps_table     }
+    end
+  end
+
+  def results_tracking_block(stage:)
+    proc do |sliced_input, response, page, pages, done, total|
+      # yields the result of each batch
+
+      input_response = input_unit_response_class.new(
+        sliced_input,
+        response
+      )
+
+      results.add_response(
+        stage,
+        input_response
+      )
+
+      # early detection of errors
+      self.error ||= page_errors?(
+        input_response,
+        page,
+        pages,
+        done,
+        total,
+        stage: stage
+      )
+    end
+  end
+
+  private
+
+  # Work with adapted diff builders.
+  def nodes_diff_class
+    Eco::API::UseCases::GraphQL::Helpers::Location::Command::Diffs
+  end
+
+  # Before closing, run RE-ARCHIVE: those that where unarchived via archivedToken
+  # that should remain archived.
+  # @note this is an additional necessary step
+  def rearchive
+    return if exception?
+    return unless rearchive_comparer.respond_to?(:stage_commands)
+    return unless rearchive_diffs.any?
+
+    rearchive_commands = rearchive_comparer.stage_commands(:archive)
+    return unless rearchive_commands.any?
+
+    # create draft, just in case it wasn't already created
+    results.draft ||= create_draft(
+      results.structure_id,
+      &create_payload_without_structure_block
+    ).draft
+
+    stage = :rearchive
+
+    rearchive_comparer.tap do
+      archive_input = input(
+        rearchive_commands,
+        force_continue: true
+      )
+
+      sliced_batches(
+        archive_input,
+        desc: stage,
+        &results_tracking_block(stage: stage)
+      )
+    rescue StandardError => err
+      log(:error) { err.patch_full_message }
+      raise
     end
   end
 
-  # Default tree tacking behaviour
-  # @note
-  #   1. This aims to optimize the time run
-  #   2. Based on update stage, there are differentiated tracking needs
-  # @return [Symbol] the tracking mode
-  def batch_tree_track_mode(stage)
-    case stage
-    when :unarchive, :archive
-      :once
-    when :id, :id_name
-      :per_request
-    when :insert, :move
-      :per_batch
+  # @note this is the 2nd and last spot where we do require a current tree structure.
+  def rearchive_comparer
+    @rearchive_comparer ||= nodes_diff_class.new(
+      as_nodes_json(current_tree), # hash_list(current_tree),
+      file_nodes_list,
+      original_tree: current_tree,
+      logger:        logger
+    )
+  end
+  alias_method :rearchive_diffs, :rearchive_comparer
+
+  def refetch_draft
+    return unless results.draft
+
+    results.draft = fetch_draft(
+      results.draft_id,
+      structure_id: results.structure_id
+    )
+
+    track_current_tree(results.structure)
+
+    results.draft
+  end
+
+  def delete_or_publish_draft
+    return unless results.draft_id
+
+    if simulate? || error? || exception?
+      delete = true
+
+      if simulate?
+        delete = false
+        should_delete? { delete = true}
+      end
+
+      delete_draft(results.draft_id) if delete
     else
-      default_tree_tracking_mode
+      results.final_response(
+        publish_draft(
+          results.draft_id,
+          &publish_payload_without_structure_block
+        )
+      )
+    end
+  end
+
+  def should_delete?
+    session.prompt_user(
+      'Should delete temporary draft? (Y/n):',
+      default: 'Y',
+      timeout: 5
+    ) do |response|
+      next unless response.upcase.start_with?('Y')
+
+      yield
     end
   end
+
+  def manage_remaps_table
+    return unless results.final_response?
+
+    rescued do
+      results.applied_commands(with_id_change: true) do |result|
+        update_tags_remap_table(result.command)
+      end
+    end
+
+    rescued { self.tags_remap_csv_file = generate_tags_remap_csv }
+    rescued { close_handling_tags_remap_csv }
+  end
 end