@shopify/cli-kit 3.38.0 → 3.40.0

package/assets/cli-ruby/lib/shopify_cli/theme/syncer/uploader/forms/apply_to_all.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+require_relative "apply_to_all_form"
+
+module ShopifyCLI
+  module Theme
+    class Syncer
+      class Uploader
+        module Forms
+          class ApplyToAll
+            attr_reader :value
+
+            def initialize(ctx, number_of_files)
+              @ctx = ctx
+              @number_of_files = number_of_files
+              @value = nil
+              @apply = nil
+            end
+
+            def apply?(value)
+              return unless @number_of_files > 1
+
+              if @apply.nil?
+                @apply = ask.apply?
+                @value = value if @apply
+              end
+
+              @apply
+            end
+
+            private
+
+            def ask
+              ApplyToAllForm.ask(@ctx, [], number_of_files: @number_of_files)
+            end
+          end
+        end
+      end
+    end
+  end
+end

package/assets/cli-ruby/lib/shopify_cli/theme/syncer/uploader/forms/apply_to_all_form.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module ShopifyCLI
+  module Theme
+    class Syncer
+      class Uploader
+        module Forms
+          class ApplyToAllForm < ShopifyCLI::Form
+            attr_accessor :apply
+            flag_arguments :number_of_files
+
+            def ask
+              title = message("title", number_of_files - 1)
+
+              self.apply = CLI::UI::Prompt.ask(title, allow_empty: false) do |handler|
+                handler.option(message("yes")) { true }
+                handler.option(message("no")) { false }
+              end
+
+              self
+            end
+
+            def apply?
+              apply
+            end
+
+            private
+
+            def message(key, *params)
+              ctx.message("theme.serve.syncer.forms.apply_to_all.#{key}", *params)
+            end
+          end
+        end
+      end
+    end
+  end
+end

package/assets/cli-ruby/lib/shopify_cli/theme/syncer/uploader/forms/base_strategy_form.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+module ShopifyCLI
+  module Theme
+    class Syncer
+      class Uploader
+        module Forms
+          class BaseStrategyForm < ShopifyCLI::Form
+            attr_accessor :strategy
+
+            def ask
+              ctx.puts(title_context(file))
+
+              self.strategy = CLI::UI::Prompt.ask(title_question, allow_empty: false) do |handler|
+                strategies.each do |strategy|
+                  handler.option(as_text(strategy)) { strategy }
+                end
+              end
+
+              exit_cli if self.strategy == :exit
+
+              self
+            end
+
+            protected
+
+            ##
+            # List of strategies that populate the form options
+            #
+            def strategies
+              raise "`#{self.class.name}#strategies' must be defined"
+            end
+
+            ##
+            # Message prefix for the form title and options (strategies).
+            # See the methods `title` and `as_text`
+            #
+            def prefix
+              raise "`#{self.class.name}#prefix' must be defined"
+            end
+
+            private
+
+            def exit_cli
+              exit(0)
+            end
+
+            def title_context(file)
+              ctx.message("#{prefix}.title_context", file.relative_path)
+            end
+
+            def title_question
+              ctx.message("#{prefix}.title_question")
+            end
+
+            def as_text(strategy)
+              ctx.message("#{prefix}.#{strategy}")
+            end
+          end
+        end
+      end
+    end
+  end
+end

package/assets/cli-ruby/lib/shopify_cli/theme/syncer/uploader/forms/select_delete_strategy.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require_relative "base_strategy_form"
+
+module ShopifyCLI
+  module Theme
+    class Syncer
+      class Uploader
+        module Forms
+          class SelectDeleteStrategy < BaseStrategyForm
+            flag_arguments :file
+
+            def strategies
+              %i[
+                delete
+                restore
+                exit
+              ]
+            end
+
+            def prefix
+              "theme.serve.syncer.forms.delete_strategy"
+            end
+          end
+        end
+      end
+    end
+  end
+end

package/assets/cli-ruby/lib/shopify_cli/theme/syncer/uploader/forms/select_update_strategy.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require_relative "base_strategy_form"
+
+module ShopifyCLI
+  module Theme
+    class Syncer
+      class Uploader
+        module Forms
+          class SelectUpdateStrategy < BaseStrategyForm
+            flag_arguments :file, :exists_remotely
+
+            def strategies
+              %i[
+                keep_remote
+                keep_local
+                union_merge
+                exit
+              ]
+            end
+
+            def prefix
+              "theme.serve.syncer.forms.#{exists_remotely ? "update_strategy" : "update_remote_deleted_strategy"}"
+            end
+          end
+        end
+      end
+    end
+  end
+end

package/assets/cli-ruby/lib/shopify_cli/theme/syncer/uploader/json_delete_handler.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+require_relative "forms/apply_to_all"
+require_relative "forms/select_delete_strategy"
+
+module ShopifyCLI
+  module Theme
+    class Syncer
+      class Uploader
+        module JsonDeleteHandler
+          def enqueue_json_deletes(files)
+            return enqueue_deletes(files) if overwrite_json?
+
+            # Handle conflicts when JSON files cannot be overwritten
+            handle_delete_conflicts(files)
+          end
+
+          private
+
+          def handle_delete_conflicts(files)
+            to_delete = []
+            to_get = []
+
+            apply_to_all = Forms::ApplyToAll.new(ctx, files.size)
+
+            files.each do |file|
+              delete_strategy = apply_to_all.value || ask_delete_strategy(file)
+              apply_to_all.apply?(delete_strategy)
+
+              case delete_strategy
+              when :delete
+                to_delete << file
+              when :restore
+                to_get << file
+              end
+            end
+
+            enqueue_deletes(to_delete)
+            enqueue_get(to_get)
+          end
+
+          def ask_delete_strategy(file)
+            Forms::SelectDeleteStrategy.ask(ctx, [], file: file).strategy
+          end
+        end
+      end
+    end
+  end
+end

package/assets/cli-ruby/lib/shopify_cli/theme/syncer/uploader/json_update_handler.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+require_relative "forms/apply_to_all"
+require_relative "forms/select_update_strategy"
+
+module ShopifyCLI
+  module Theme
+    class Syncer
+      class Uploader
+        module JsonUpdateHandler
+          def enqueue_json_updates(files)
+            return enqueue_updates(files) if overwrite_json?
+
+            # Handle conflicts when JSON files cannot be overwritten
+            handle_update_conflicts(files)
+          end
+
+          private
+
+          def handle_update_conflicts(files)
+            to_get = []
+            to_delete = []
+            to_update = []
+            to_union_merge = []
+
+            apply_to_all = Forms::ApplyToAll.new(ctx, files.size)
+
+            files.each do |file|
+              update_strategy = apply_to_all.value || ask_update_strategy(file)
+              apply_to_all.apply?(update_strategy)
+
+              case update_strategy
+              when :keep_remote
+                if file_exist_remotely?(file)
+                  to_get << file
+                else
+                  delete_locally(file)
+                end
+              when :keep_local
+                to_update << file
+              when :union_merge
+                if file_exist_remotely?(file)
+                  to_union_merge << file
+                else
+                  to_update << file
+                end
+              end
+            end
+
+            enqueue_get(to_get)
+            enqueue_deletes(to_delete)
+            enqueue_updates(to_update)
+            enqueue_union_merges(to_union_merge)
+          end
+
+          def file_exist_remotely?(file)
+            !checksums[file.relative_path].nil?
+          end
+
+          def delete_locally(file)
+            ::File.delete(file.absolute_path)
+          end
+
+          def ask_update_strategy(file)
+            Forms::SelectUpdateStrategy.ask(ctx, [], file: file, exists_remotely: file_exist_remotely?(file)).strategy
+          end
+        end
+      end
+    end
+  end
+end

package/assets/cli-ruby/lib/shopify_cli/theme/syncer/uploader.rb

@@ -0,0 +1,231 @@
+# frozen_string_literal: true
+
+require "forwardable"
+
+require_relative "uploader/bulk_item"
+require_relative "uploader/bulk"
+require_relative "uploader/json_delete_handler"
+require_relative "uploader/json_update_handler"
+
+module ShopifyCLI
+  module Theme
+    class Syncer
+      class Uploader
+        extend Forwardable
+
+        include JsonDeleteHandler
+        include JsonUpdateHandler
+
+        attr_reader :syncer
+
+        def_delegators :syncer,
+          # helpers
+          :ctx,
+          :api_client,
+          :theme,
+          :ignore_file?,
+          :overwrite_json?,
+          :bulk_updates_activated?,
+          # enqueue
+          :enqueue_deletes,
+          :enqueue_get,
+          :enqueue_union_merges,
+          :enqueue_updates,
+          # checksums
+          :checksums,
+          :update_checksums,
+          :fetch_checksums!,
+          :wait!
+
+        def initialize(syncer, delete, delay_low_priority_files, &update_progress_bar_block)
+          @syncer = syncer
+          @delete = delete
+          @delay_low_priority_files = delay_low_priority_files
+          @update_progress_bar_block = update_progress_bar_block
+          @progress_bar_mutex = Mutex.new
+        end
+
+        def upload!
+          fetch_checksums!
+          delete_files!
+
+          if bulk_updates_activated? && overwrite_json?
+            bulk_upload!
+          else
+            async_upload!
+          end
+        end
+
+        def delete_files!
+          return unless delete?
+
+          files_present_remotely = checksums.keys
+          files_present_locally = theme.theme_files.map(&:relative_path)
+
+          json_files, other_files = (files_present_remotely - files_present_locally)
+            .map { |file| theme[file] }
+            .reject { |file| ignore_file?(file) }
+            .partition(&:json?)
+
+          enqueue_deletes(other_files)
+          enqueue_json_deletes(json_files)
+        end
+
+        private
+
+        def bulk_upload!
+          update_progress_bar!
+
+          enqueue_bulk_updates(liquid_files)
+          enqueue_bulk_updates(json_files)
+          enqueue_bulk_updates(config_files)
+
+          if delay_low_priority_files?
+            # Process lower-priority files (assets) in the background, as they
+            # are served locally
+            enqueue_updates(static_asset_files)
+          else
+            enqueue_bulk_updates(static_asset_files)
+          end
+
+          wait!(&@update_progress_bar_block) unless delay_low_priority_files?
+        end
+
+        def async_upload!
+          enqueue_updates(liquid_files)
+          enqueue_json_updates(json_files)
+          enqueue_updates(config_files)
+
+          # Wait upload of Liquid & JSON files, as they are rendered remotely
+          wait!(&@update_progress_bar_block) if delay_low_priority_files?
+
+          # Process lower-priority files (assets) in the background, as they
+          # are served locally
+          enqueue_updates(static_asset_files)
+
+          wait!(&@update_progress_bar_block) unless delay_low_priority_files?
+        end
+
+        def enqueue_bulk_updates(files)
+          retries = 0
+          pending_items = files.map { |file| bulk_item(file) }
+
+          while pending_items.any? && retries < 2
+            bulk = Bulk.new(ctx, theme, api_client)
+
+            files
+              .map { |file| bulk_item(file) }
+              .each { |request| bulk.enqueue(request) }
+
+            bulk.shutdown
+
+            retries += 1
+            pending_items = bulk.remaining_items
+          end
+
+          return unless pending_items.any?
+
+          # Remaining items are handled in the background when the bulk timeout
+          # is exceeded
+          pending_items.size.times { update_progress_bar! }
+
+          syncer.enqueue_updates(pending_items.map(&:file))
+          syncer.wait!
+        end
+
+        def bulk_item(file)
+          BulkItem.new(file) do |_s, body, response|
+            if response.is_a?(StandardError)
+              report(file, response)
+            else
+              update_checksums(body)
+            end
+          ensure
+            update_progress_bar!
+          end
+        end
+
+        def delete?
+          @delete
+        end
+
+        def delay_low_priority_files?
+          @delay_low_priority_files
+        end
+
+        # Files
+
+        def number_of_bulk_items
+          @number_of_files ||= [
+            json_files.size,
+            liquid_files.size,
+            config_files.size,
+            delay_low_priority_files? ? 0 : static_asset_files.size,
+          ].reduce(:+)
+        end
+
+        def json_files
+          @json_files ||= uploadable(theme.json_files) - config_files
+        end
+
+        def liquid_files
+          @liquid_files ||= uploadable(theme.liquid_files)
+        end
+
+        def static_asset_files
+          @static_asset_files ||= uploadable(theme.static_asset_files)
+        end
+
+        def config_files
+          @config_files ||= uploadable(
+            [
+              theme["config/settings_schema.json"],
+              theme["config/settings_data.json"],
+            ],
+          )
+        end
+
+        def uploadable(files)
+          files.select { |file| uploadable?(file) }
+        end
+
+        def uploadable?(file)
+          return false unless file.exist?
+          return false if ignore_file?(file)
+
+          checksums.file_has_changed?(file)
+        end
+
+        # Handle prorgress bar
+
+        def update_progress_bar!
+          @pending_files ||= number_of_bulk_items
+          @pending_files -= 1
+
+          # Avoid abrupt updates in the progress bar
+          @progress_bar_mutex.synchronize do
+            sleep(0.02)
+            update_progress_bar(@pending_files, number_of_bulk_items)
+          end
+        end
+
+        def update_progress_bar(size, total)
+          @update_progress_bar_block&.call(size, total)
+        end
+
+        # Handler errors
+
+        def report(file, error)
+          file_path = file.relative_path
+
+          error_message = syncer
+            .parse_api_errors(file, error)
+            .map { |msg| "#{file_path}: #{msg}" }
+            .join("\n")
+
+          syncer.report_file_error(file, error_message)
+        end
+      end
+    end
+  end
+end