eco-helpers 3.2.2 → 3.2.3

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

@@ -1,63 +1,133 @@
 module Eco::API::UseCases::GraphQL::Helpers::Location::Command
+  # Final ressults of the full run.
   class Results
-    attr_reader :input, :response
+    attr_accessor :draft
 
-    def initialize(input, response)
-      @input    = input
-      @response = response
+    def draft_id
+      draft&.id
     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 parent_structure
+      draft&.parent_structure
     end
 
-    # Was this configured to force-continue on command error?
-    def force?
-      input[:force]
+    # @note target parent structure id
+    def structure_id
+      draft&.structure_id
     end
 
-    # # Offers a summary. If anything went wrong, it's `false`.
-    # # If everything went right, it's `true`.
-    # def ok?
-    #   response&.ok
-    # end
+    # @note the result of the draft
+    def structure
+      draft&.structure
+    end
 
-    # Overal errors (i.e. ID clashes between different structures)
-    def error
-      response&.error
+    # @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_result(input)
-      results_by_input[input]
+    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 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,24 +135,28 @@ 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?
@@ -94,11 +168,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 +177,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,25 +3,10 @@ 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
-
-    # 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
+    require_relative 'command/end_points'
+    include Eco::API::UseCases::GraphQL::Helpers::Location::Command::EndPoints
 
+    # @note it does the API call.
     # @param track_tree_mode [Symbol] when should updates happen
     # @return see #with_sliced_input
     def sliced_batches(
@@ -46,17 +31,31 @@ 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}")
+          backup(
+            sliced_input,
+            type: "tree_update_#{desc}_request_#{page}_of_#{pages}"
+          )
         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)
+        response = apply_commands(
+          sliced_input,
+          final:           (page == pages),
+          track_tree_mode: track_tree_mode
+        )
+
+        unless simulate?
+          backup(
+            response,
+            type: "tree_update_#{desc}_response_#{page}_of_#{pages}"
+          )
         end
 
         done += count
@@ -88,6 +87,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,51 @@
 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
+
+    # Default tree tacking behaviour
+    # @note
+    #   1. This aims to optimize the time run
+    #   2. Based on update stage, there are differentiated tracking needs
+    # @note Available options are:
+    #   - :per_request -> on each request
+    #   - :per_batch   -> at the end of each batch / stage (on last page)
+    #   - :once        -> only when the script starts to run
+    # @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
+      else
+        default_tree_tracking_mode
+      end
+    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).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,14 +58,27 @@ 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
+    # MAIN PROCESSOR
+    def process
       self.error = false
 
       with_error_handling do
@@ -32,49 +87,152 @@ class Eco::API::UseCases::GraphQL::Samples::Location
         # this may trigger a backup of the tagtree
         self.current_tree ||= live_tree
 
-        inputs(force_continue: force_continue?) do |input, stage|
-          results[stage] ||= []
-
-          track_mode = batch_tree_track_mode(stage)
-
-          # 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)
-
-            results[stage] << (page_results = request_results_class.new(sliced_input, response))
-            update_tags_remap_table(page_results, stage, current_tree)
+        inputs(
+          force_continue: force_continue?
+        ) do |input, stage|
+          next unless input
 
-            self.error = page_errors?(page_results, page, pages, done, total, stage: stage)
-            break if error
-          end
+          sliced_batches(
+            input,
+            desc:            stage,
+            track_tree_mode: batch_tree_track_mode(stage),
+            &results_tracking_block(stage: stage)
+          )
 
-          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 { rearchive } unless exception
+      rescued { delete_or_publish_draft }
+      rescued { manage_remaps_table     }
     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
+  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
+      )
+
+      # @todo: might need to set the name and the id by treeifying here.
+      #   Alternatively, add named arguments id and name.
+      track_current_tree(results.structure)
+
+      # 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?
+
+    results.draft ||= create_draft(current_tree.id).draft
+
+    stage = :rearchive
+
+    rearchive_comparer.tap do
+      archive_input = input(
+        rearchive_commands,
+        force_continue: true
+      )
+
+      sliced_batches(
+        archive_input,
+        desc:            stage,
+        track_tree_mode: :once,
+        &results_tracking_block(stage: stage)
+      )
+    rescue StandardError => err
+      log(:error) { err.patch_full_message }
+      raise
+    end
+  end
+
+  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 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)
+      )
+    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

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

@@ -5,46 +5,78 @@ class Eco::API::UseCases::GraphQL::Samples::Location
 
     attr_accessor :error
 
-    def request_results_class
+    def error?
+      !!error
+    end
+
+    def input_unit_response_class
+      Eco::API::UseCases::GraphQL::Helpers::Location::Command::InputUnitResponse
+    end
+
+    def run_results_class
       Eco::API::UseCases::GraphQL::Helpers::Location::Command::Results
     end
 
     # Capture results
     def results
-      @results ||= {}
+      @results ||= run_results_class.new
     end
 
     # Errors tracking/logging.
     # @note it gives feedback on where an error has occurred.
-    # @param page_results [Eco::API::UseCases::GraphQL::Helpers::Locations::Commands::CommandResults]
+    # @param input_unit_response [Eco::API::UseCases::GraphQL::Helpers::Locations::Commands::CommandResults]
     # @param stage [Symbol] used when we launch an update in different phases (i.e. rename, move, etc.)
     # @return [Boolean] whether or not there was an error
-    def page_errors?(page_results, page, pages, done, total, stage: nil)
-      msg = "Expecting CommandResults object. Given: #{page_results.class}"
-      raise msg unless page_results.is_a?(request_results_class)
+    def page_errors?(input_unit_response, page, pages, done, total, stage: nil)
+      msg = "Expecting CommandResults object. Given: #{input_unit_response.class}"
+      raise msg unless input_unit_response.is_a?(input_unit_response_class)
 
       stage_str   = stage ? "'#{stage}' " : ''
       fingerprint = "#{stage_str}#{page} (of #{pages})"
-      errored     = false
 
-      if page_results.error?
+      if (errored = input_unit_response.error?)
+        log(:error) {
+          msg  = "Error on #{fingerprint}: "
+          msg << JSON.pretty_generate(input_unit_response.error_doc)
+          msg
+        }
+      else
+        log(:info) {
+          "Success on #{fingerprint}: #{done} (of #{total}) commands added!"
+        }
+      end
+
+      errored
+    end
+
+    def result_errors?
+      errored = false
+
+      if results.error?
         errored = true
         log(:error) {
-          "Error on #{fingerprint}: #{page_results.error.doc.pretty_inspect}"
+          msg  = "Error on #{fingerprint}: "
+          msg << JSON.pretty_generate(input_unit_response.error_doc)
+          msg
         }
       end
 
-      if page_results.applied?
+      # @todo: intermediate status check on drafts doesn't rely on applied
+      #   This is rather to be done at the very end, when publishing the draft.
+      if input_unit_response.applied?
         log(:info) {
           "Success on #{fingerprint}: #{done} (of #{total}) commands applied!"
         }
-      elsif page_results.errored?
+      elsif input_unit_response.errored?
         errored = true
-        msg     = "Some command failed on #{fingerprint}:\n#{page_results.stats}"
+        msg     = "Some command failed on #{fingerprint}:\n"
+        msg    << input_unit_response.stats
+
         unless force_continue?
-          first_errored = page_results.first_errored
+          first_errored = input_unit_response.first_errored
           msg << "The error(s) - #{first_errored.error_msg}\n"
         end
+
         log(:error) { msg }
       end