shopify-cli 2.29.0 → 2.30.0

data/lib/shopify_cli/theme/syncer/json_delete_handler.rb

@@ -1,51 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "forms/apply_to_all"
-require_relative "forms/select_delete_strategy"
-
-module ShopifyCLI
-  module Theme
-    class Syncer
-      module JsonDeleteHandler
-        def enqueue_json_deletes(files)
-          files = files.select { |file| !ignore_file?(file) }
-
-          if overwrite_json?
-            enqueue_deletes(files)
-          else
-            # Handle conflicts when JSON files cannot be overwritten
-            handle_delete_conflicts(files)
-          end
-        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

data/lib/shopify_cli/theme/syncer/json_update_handler.rb

@@ -1,96 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "forms/apply_to_all"
-require_relative "forms/select_update_strategy"
-
-module ShopifyCLI
-  module Theme
-    class Syncer
-      module JsonUpdateHandler
-        def enqueue_json_updates(files)
-          # Update remote JSON files and delays `delayed_files` update
-          files = files
-            .select { |file| ready_to_update?(file) }
-            .sort_by { |file| delayed_files.include?(file) ? 1 : 0 }
-            .reject { |file| overwrite_json? && delayed_files.include?(file) }
-
-          if overwrite_json?
-            enqueue_updates(files)
-          else
-            # Handle conflicts when JSON files cannot be overwritten
-            handle_update_conflicts(files)
-          end
-        end
-
-        def enqueue_delayed_files_updates
-          return unless overwrite_json?
-          # Update delayed files synchronously
-          delayed_files.each do |file|
-            update(file) if ready_to_update?(file)
-          end
-        end
-
-        def delayed_files
-          [
-            theme["config/settings_schema.json"],
-            theme["config/settings_data.json"],
-          ]
-        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
-
-        def ready_to_update?(file)
-          !ignore_file?(file) && file.exist? && checksums.file_has_changed?(file)
-        end
-      end
-    end
-  end
-end

data/lib/shopify_cli/theme/theme_admin_api_throttler/bulk.rb

@@ -1,102 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "bulk_job"
-require "shopify_cli/thread_pool"
-
-module ShopifyCLI
-  module Theme
-    class ThemeAdminAPIThrottler
-      class Bulk
-        MAX_BULK_BYTESIZE = 10_485_760 # 10MB
-        MAX_BULK_FILES = 20 # files
-        QUEUE_TIMEOUT = 0.2 # 200ms
-
-        attr_accessor :admin_api
-
-        def initialize(ctx, admin_api, pool_size: 20)
-          @ctx = ctx
-          @admin_api = admin_api
-          @latest_enqueued_at = now
-
-          @thread_pool = ShopifyCLI::ThreadPool.new(pool_size: pool_size)
-
-          pool_size.times do
-            @thread_pool.schedule(
-              BulkJob.new(ctx, self)
-            )
-          end
-
-          @put_requests = []
-          @mut = Mutex.new
-        end
-
-        def enqueue(put_request)
-          @mut.synchronize do
-            @latest_enqueued_at = now
-            @put_requests << put_request
-          end
-        end
-
-        def shutdown
-          wait_put_requests
-          @thread_pool.shutdown
-        end
-
-        def consume_put_requests
-          to_batch = []
-          to_batch_size_bytes = 0
-          @mut.synchronize do
-            # sort requests to perform less retries at the `bulk_job` level
-            @put_requests.sort_by! { |r| r.liquid? ? 0 : 1 }
-
-            is_ready = false
-            until is_ready || @put_requests.empty?
-              request = @put_requests.first
-              if to_batch.empty? && request.size > MAX_BULK_BYTESIZE
-                is_ready = true
-                to_batch << request
-                to_batch_size_bytes += request.size
-                @put_requests.shift
-              elsif to_batch.size + 1 > MAX_BULK_FILES || to_batch_size_bytes + request.size > MAX_BULK_BYTESIZE
-                is_ready = true
-              else
-                to_batch << request
-                to_batch_size_bytes += request.size
-                @put_requests.shift
-              end
-            end
-          end
-          [to_batch, to_batch_size_bytes]
-        end
-
-        def ready?
-          queue_timeout? || bulk_size >= MAX_BULK_FILES || bulk_bytesize >= MAX_BULK_BYTESIZE
-        end
-
-        def bulk_bytesize
-          @put_requests.map(&:size).reduce(:+).to_i
-        end
-
-        private
-
-        def bulk_size
-          @put_requests.size
-        end
-
-        def queue_timeout?
-          return false if bulk_size.zero?
-          elapsed_time = now - @latest_enqueued_at
-          elapsed_time > QUEUE_TIMEOUT
-        end
-
-        def wait_put_requests
-          sleep(0.2) until @put_requests.empty?
-        end
-
-        def now
-          Time.now.to_f
-        end
-      end
-    end
-  end
-end

data/lib/shopify_cli/theme/theme_admin_api_throttler/bulk_job.rb

@@ -1,75 +0,0 @@
-# frozen_string_literal: true
-
-require "shopify_cli/thread_pool/job"
-require_relative "request_parser"
-require_relative "response_parser"
-require_relative "errors"
-
-module ShopifyCLI
-  module Theme
-    class ThemeAdminAPIThrottler
-      class BulkJob < ShopifyCLI::ThreadPool::Job
-        JOB_TIMEOUT = 0.2 # 200ms
-        MAX_RETRIES = 10
-
-        attr_reader :bulk
-
-        def initialize(ctx, bulk)
-          super(JOB_TIMEOUT)
-          @ctx = ctx
-          @bulk = bulk
-
-          # Mutex used to coordinate changes performed by the bulk item block
-          @block_mutex = Mutex.new
-        end
-
-        def perform!
-          return unless bulk.ready?
-          put_requests, bulk_size = bulk.consume_put_requests
-          return if put_requests.empty?
-
-          @ctx.debug("[BulkJob] size: #{put_requests.size}, bytesize: #{bulk_size}")
-          bulk_status, bulk_body, response = rest_request(put_requests)
-
-          if bulk_status == 207
-            responses(bulk_body).each_with_index do |tuple, index|
-              status, body = tuple
-              put_request = put_requests[index]
-              if status == 200 || put_request.retries >= MAX_RETRIES
-                @block_mutex.synchronize do
-                  if status == 200
-                    @ctx.debug("[BulkJob] asset saved: #{put_request.key}")
-                    put_request.block.call(status, body, response)
-                  else
-                    @ctx.debug("[BulkJob] asset continuing with error: #{put_request.key}")
-                    err = AssetUploadError.new(body, response: { body: body })
-                    put_request.block.call(status, {}, err)
-                  end
-                end
-              else
-                @ctx.debug("[BulkJob] asset error: #{put_request.key}")
-                @block_mutex.synchronize do
-                  put_request.retries += 1
-                  bulk.enqueue(put_request)
-                end
-              end
-            end
-          else
-            @ctx.puts(@ctx.message("theme.stable_flag_suggestion"))
-          end
-        end
-
-        private
-
-        def rest_request(put_requests)
-          request = RequestParser.new(put_requests).parse
-          bulk.admin_api.rest_request(**request)
-        end
-
-        def responses(response_body)
-          ResponseParser.new(response_body).parse
-        end
-      end
-    end
-  end
-end

data/lib/shopify_cli/theme/theme_admin_api_throttler/errors.rb

@@ -1,7 +0,0 @@
-module ShopifyCLI
-  module Theme
-    class ThemeAdminAPIThrottler
-      class AssetUploadError < ShopifyCLI::API::APIRequestError; end
-    end
-  end
-end

data/lib/shopify_cli/theme/theme_admin_api_throttler/put_request.rb

@@ -1,52 +0,0 @@
-# frozen_string_literal: true
-
-require "shopify_cli/thread_pool/job"
-require_relative "request_parser"
-require_relative "response_parser"
-
-module ShopifyCLI
-  module Theme
-    class ThemeAdminAPIThrottler
-      class PutRequest
-        attr_reader :method, :body, :path, :block
-        attr_accessor :retries
-
-        def initialize(path, body, &block)
-          @method = "PUT"
-          @path = path
-          @body = body
-          @block = block
-          @retries = 0
-        end
-
-        def to_h
-          {
-            method: method,
-            path: path,
-            body: body,
-          }
-        end
-
-        def to_s
-          "#{key}, retries: #{retries}"
-        end
-
-        def liquid?
-          key.end_with?(".liquid")
-        end
-
-        def key
-          @key ||= JSON.parse(body)["asset"]["key"]
-        end
-
-        def bulk_path
-          path.gsub(/.json$/, "/bulk.json")
-        end
-
-        def size
-          @size ||= body.bytesize
-        end
-      end
-    end
-  end
-end

data/lib/shopify_cli/theme/theme_admin_api_throttler/request_parser.rb

@@ -1,39 +0,0 @@
-# frozen_string_literal: true
-
-module ShopifyCLI
-  module Theme
-    class ThemeAdminAPIThrottler
-      class RequestParser
-        def initialize(requests)
-          @requests = requests
-        end
-
-        def parse
-          {
-            path: path,
-            method: method,
-            body: JSON.generate({ assets: assets }),
-          }
-        end
-
-        private
-
-        def method
-          @requests.sample.method
-        end
-
-        def path
-          @requests.sample.bulk_path
-        end
-
-        def assets
-          @requests.map do |request|
-            body = JSON.parse(request.body)
-            body = body.is_a?(Hash) ? body : JSON.parse(body)
-            body["asset"]
-          end
-        end
-      end
-    end
-  end
-end

data/lib/shopify_cli/theme/theme_admin_api_throttler/response_parser.rb

@@ -1,21 +0,0 @@
-# frozen_string_literal: true
-
-module ShopifyCLI
-  module Theme
-    class ThemeAdminAPIThrottler
-      class ResponseParser
-        def initialize(response_body)
-          @response_body = response_body
-        end
-
-        def parse
-          result = []
-          @response_body["results"]&.each do |resp|
-            result << [resp["code"], resp["body"]]
-          end
-          result
-        end
-      end
-    end
-  end
-end

data/lib/shopify_cli/theme/theme_admin_api_throttler.rb

@@ -1,62 +0,0 @@
-# frozen_string_literal: true
-
-require "forwardable"
-
-require_relative "theme_admin_api_throttler/bulk"
-require_relative "theme_admin_api_throttler/put_request"
-
-module ShopifyCLI
-  module Theme
-    class ThemeAdminAPIThrottler
-      extend Forwardable
-
-      attr_reader :bulk, :admin_api
-
-      def_delegators :@admin_api, :get, :post, :delete
-
-      def initialize(ctx, admin_api, active = true)
-        @ctx = ctx
-        @admin_api = admin_api
-        @active = active
-        @bulk = Bulk.new(ctx, admin_api)
-      end
-
-      def put(path:, **args, &block)
-        request = PutRequest.new(path, args[:body], &block)
-        if active?
-          bulk_request(request)
-        else
-          rest_request(request)
-        end
-      end
-
-      def activate_throttler!
-        @active = true
-      end
-
-      def deactivate_throttler!
-        @active = false
-      end
-
-      def active?
-        @active
-      end
-
-      def shutdown
-        bulk.shutdown
-      end
-
-      private
-
-      def rest_request(request)
-        request.block.call(admin_api.rest_request(**request.to_h))
-      rescue StandardError => error
-        request.block.call(500, {}, error)
-      end
-
-      def bulk_request(request)
-        bulk.enqueue(request)
-      end
-    end
-  end
-end