@shopify/cli 3.69.4 → 3.70.0

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

@@ -1,133 +0,0 @@
-# frozen_string_literal: true
-
-require "shopify_cli/thread_pool"
-require "shopify_cli/theme/backoff_helper"
-
-require_relative "bulk_job"
-
-module ShopifyCLI
-  module Theme
-    class Syncer
-      class Uploader
-        class Bulk
-          include ShopifyCLI::Theme::BackoffHelper
-
-          MAX_BULK_BYTESIZE = 102_400   # 100KB
-          MAX_BULK_FILES = 10           # 10 files
-          SHUTDOWN_TIMEOUT = 20         # 20 seconds
-          SHUTDOWN_RETRY_INTERVAL = 0.2 # 200 milliseconds
-
-          attr_reader :ctx, :theme, :admin_api
-
-          def initialize(ctx, theme, admin_api, pool_size: 15)
-            @ctx = ctx
-            @theme = theme
-            @admin_api = admin_api
-            @pending_items = []
-            @in_progress_items = []
-
-            # Mutex used to coordinate changes in the `@pending_items` shared
-            # accross the `@thread_pool` threads
-            @pending_items_mutex = Mutex.new
-
-            # Mutex used to coordinate changes in the `@in_progress_items`
-            # shared accross the `@thread_pool` threads
-            @in_progress_items_mutex = Mutex.new
-
-            # Initialize thread pool and the jobs
-            @thread_pool = initialize_thread_pool!(pool_size)
-
-            # Initialize backoff helper on main thread to pause all jobs when
-            # requests are reaching API rate limits
-            initialize_backoff_helper!(margin: pool_size, backoff_delay: 5)
-          end
-
-          def enqueue(bulk_item)
-            @pending_items_mutex.synchronize { @pending_items << bulk_item }
-          end
-
-          def shutdown
-            wait_bulk_items
-            @thread_pool.shutdown
-          end
-
-          def consume_bulk_items
-            items = []
-            items_bytesize = 0
-
-            @pending_items_mutex.synchronize do
-              has_enough_items = false
-              has_enough_bytesize = false
-
-              until has_enough_items || has_enough_bytesize || @pending_items.empty?
-                bulk_item = @pending_items.first
-
-                has_enough_items = items.size + 1 > MAX_BULK_FILES
-                has_enough_bytesize = items_bytesize + bulk_item.size > MAX_BULK_BYTESIZE
-
-                break if items.any? && (has_enough_items || has_enough_bytesize)
-
-                items << bulk_item
-                items_bytesize += bulk_item.size
-
-                @pending_items.shift
-              end
-            end
-
-            @in_progress_items_mutex.synchronize do
-              @in_progress_items += items
-            end
-
-            [items, items_bytesize]
-          end
-
-          def clean_in_progress_items(items)
-            @in_progress_items_mutex.synchronize do
-              @in_progress_items -= items
-            end
-          end
-
-          def remaining_items
-            @pending_items + @in_progress_items
-          end
-
-          private
-
-          def wait_bulk_items
-            start_time = Time.now
-
-            wait(SHUTDOWN_RETRY_INTERVAL) while remaining_items? && start_time - Time.now < SHUTDOWN_TIMEOUT
-
-            files = remaining_items.map { |item| "- #{item.key}" }.join("\n")
-
-            log("shutdown, remaining_items=#{remaining_items.size}\n#{files}")
-          end
-
-          def remaining_items?
-            !@pending_items.empty? || !@in_progress_items.empty?
-          end
-
-          def initialize_thread_pool!(pool_size)
-            ShopifyCLI::ThreadPool
-              .new(pool_size: pool_size)
-              .tap do |thread_pool|
-                pool_size.times { thread_pool.schedule(spawn_job) }
-              end
-          end
-
-          def spawn_job
-            BulkJob.new(ctx, self)
-          end
-
-          def log(message)
-            ctx.debug("[Bulk] #{message}")
-          end
-
-          def wait(seconds)
-            sleep(seconds)
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,64 +0,0 @@
-# frozen_string_literal: true
-
-require "shopify_cli/thread_pool/job"
-
-module ShopifyCLI
-  module Theme
-    class Syncer
-      class Uploader
-        class BulkItem
-          attr_reader :file, :block
-          attr_accessor :retries
-
-          def initialize(file, &block)
-            @file = file
-            @block = block
-            @retries = 0
-          end
-
-          def to_h
-            { body: body }
-          end
-
-          def to_s
-            "#<#{self.class.name} key=#{key}, retries=#{retries}>"
-          end
-
-          def liquid?
-            file.liquid?
-          end
-
-          def key
-            file.relative_path
-          end
-
-          def size
-            @size ||= body.bytesize
-          end
-
-          def body
-            @body ||= JSON.generate(asset: asset)
-          end
-
-          def asset
-            @asset ||= asset_hash
-          end
-
-          private
-
-          def asset_hash
-            asset = { key: file.relative_path }
-
-            if file.text?
-              asset[:value] = file.read
-            else
-              asset[:attachment] = Base64.encode64(file.read)
-            end
-
-            asset
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,139 +0,0 @@
-# frozen_string_literal: true
-
-require "shopify_cli/thread_pool/job"
-
-require_relative "bulk_request"
-
-module ShopifyCLI
-  module Theme
-    class Syncer
-      class Uploader
-        class BulkJob < ShopifyCLI::ThreadPool::Job
-          INTERVAL = 0.2 # 200ms
-          MAX_RETRIES = 10
-
-          attr_reader :ctx, :bulk, :admin_api
-
-          def initialize(ctx, bulk)
-            super(INTERVAL)
-
-            @ctx = ctx
-            @bulk = bulk
-            @admin_api = bulk.admin_api
-
-            # Mutex used to coordinate changes in the bulk items
-            @bulk_item_mutex = Mutex.new
-
-            # Mutex used to coordinate changes in the bulk items
-            @bulk_item_mutex = Mutex.new
-          end
-
-          def perform!
-            bulk.wait_for_backoff!
-
-            # Fetch bulk items
-            bulk_items, bulk_size = bulk.consume_bulk_items
-            return if bulk_items.empty?
-
-            # Perform bulk request
-            log("job request: size=#{bulk_items.size}, bytesize=#{bulk_size}")
-            bulk_status, bulk_body, response = rest_request(bulk_items)
-            bulk.backoff_if_near_limit!(response)
-            log("job response: http_status=#{bulk_status}")
-
-            # Abort execution when a fatal error happens
-            return stable_flag_suggestion! if bulk_status != 207
-
-            # Handle item reponses
-            responses = parse_responses(bulk_body)
-            responses
-              .each_with_index do |tuple, index|
-                status, body = tuple
-                bulk_item = bulk_items[index]
-                handle_item_response(bulk_item, status, body, response)
-              end
-          ensure
-            bulk.clean_in_progress_items(bulk_items)
-          end
-
-          private
-
-          def handle_item_response(bulk_item, status, body, response)
-            if status == 200
-              return handle_success(bulk_item, status, body, response)
-            end
-
-            if bulk_item.retries < MAX_RETRIES
-              return handle_retry(bulk_item, status, body, response)
-            end
-
-            handle_error(bulk_item, status, body)
-          end
-
-          def handle_success(bulk_item, status, body, response)
-            log("bulk item success (item=#{bulk_item.key})")
-
-            @bulk_item_mutex.synchronize do
-              bulk_item.block.call(status, body, response)
-            end
-          end
-
-          def handle_retry(bulk_item, status, _body, _response)
-            key = bulk_item.key
-            retries = bulk_item.retries
-
-            log("bulk item error (item=#{key}, status=#{status}, retries=#{retries})")
-
-            @bulk_item_mutex.synchronize do
-              bulk_item.retries += 1
-              bulk.enqueue(bulk_item)
-            end
-          end
-
-          def handle_error(bulk_item, status, body)
-            log("bulk item fatal error (item=#{bulk_item.key}, status=#{status})")
-
-            @bulk_item_mutex.synchronize do
-              bulk_item.block.call(status, body, error_response(body))
-            end
-          end
-
-          def stable_flag_suggestion!
-            ctx.abort(ctx.message("theme.stable_flag_suggestion"))
-          end
-
-          def rest_request(bulk_items)
-            theme = bulk.theme
-            args = BulkRequest.new(theme, bulk_items).to_h
-
-            measure("bulk rest_request") { admin_api.rest_request(**args) }
-          end
-
-          def measure(subject)
-            return yield unless ctx.debug?
-
-            start_time = Time.now
-            result = yield
-            time_elapsed = (Time.now - start_time) * 1000
-
-            log("#{subject} time: #{time_elapsed}ms")
-
-            result
-          end
-
-          def parse_responses(body)
-            body["results"]&.map { |r| [r["code"], r["body"]] } || []
-          end
-
-          def error_response(body)
-            ShopifyCLI::API::APIRequestError.new(body, response: { body: body })
-          end
-
-          def log(message)
-            ctx.debug("[BulkJob ##{object_id}] #{message}")
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,30 +0,0 @@
-# frozen_string_literal: true
-
-module ShopifyCLI
-  module Theme
-    class Syncer
-      class Uploader
-        class BulkRequest
-          def initialize(theme, bulk_items)
-            @theme = theme
-            @bulk_items = bulk_items
-          end
-
-          def to_h
-            {
-              path: "themes/#{@theme.id}/assets/bulk.json",
-              method: "PUT",
-              body: JSON.generate({ assets: assets }),
-            }
-          end
-
-          private
-
-          def assets
-            @bulk_items.map(&:asset)
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,41 +0,0 @@
-# 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/dist/assets/cli-ruby/lib/shopify_cli/theme/syncer/uploader/forms/apply_to_all_form.rb

@@ -1,37 +0,0 @@
-# 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/dist/assets/cli-ruby/lib/shopify_cli/theme/syncer/uploader/forms/base_strategy_form.rb

@@ -1,64 +0,0 @@
-# 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/dist/assets/cli-ruby/lib/shopify_cli/theme/syncer/uploader/forms/select_delete_strategy.rb

@@ -1,29 +0,0 @@
-# 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/dist/assets/cli-ruby/lib/shopify_cli/theme/syncer/uploader/forms/select_update_strategy.rb

@@ -1,30 +0,0 @@
-# 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/dist/assets/cli-ruby/lib/shopify_cli/theme/syncer/uploader/json_delete_handler.rb

@@ -1,49 +0,0 @@
-# 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/dist/assets/cli-ruby/lib/shopify_cli/theme/syncer/uploader/json_update_handler.rb

@@ -1,71 +0,0 @@
-# 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