@shopify/cli-kit 3.39.0 → 3.40.1

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

@@ -0,0 +1,386 @@
+# frozen_string_literal: true
+
+require "thread"
+require "json"
+require "base64"
+require "forwardable"
+
+require_relative "backoff_helper"
+require_relative "ignore_helper"
+require_relative "theme_admin_api"
+
+require_relative "syncer/checksums"
+require_relative "syncer/downloader"
+require_relative "syncer/error_reporter"
+require_relative "syncer/merger"
+require_relative "syncer/operation"
+require_relative "syncer/standard_reporter"
+require_relative "syncer/unsupported_script_warning"
+require_relative "syncer/uploader"
+
+module ShopifyCLI
+  module Theme
+    class Syncer
+      extend Forwardable
+
+      include ShopifyCLI::Theme::IgnoreHelper
+      include ShopifyCLI::Theme::BackoffHelper
+
+      QUEUEABLE_METHODS = [
+        :get,         # - Updates the local file with the remote file content
+        :update,      # - Updates the remote file with the local file content
+        :delete,      # - Deletes the remote file
+        :union_merge, # - Union merges the local file content with the remote file content
+      ]
+
+      attr_reader :ctx, :theme, :checksums, :error_checksums, :api_client, :pending
+      attr_accessor :include_filter, :ignore_filter
+
+      def_delegators :@error_reporter, :has_any_error?
+
+      def initialize(ctx, theme:, include_filter: nil, ignore_filter: nil, overwrite_json: true, stable: false)
+        @ctx = ctx
+        @theme = theme
+        @include_filter = include_filter
+        @ignore_filter = ignore_filter
+        @overwrite_json = overwrite_json
+        @error_reporter = ErrorReporter.new(ctx)
+        @standard_reporter = StandardReporter.new(ctx)
+        @reporters = [@error_reporter, @standard_reporter]
+
+        # Queue of `Operation`s waiting to be picked up from a thread for processing.
+        @queue = Queue.new
+
+        # `Operation`s will be removed from this Array completed.
+        @pending = []
+
+        # Thread making the API requests.
+        @threads = []
+
+        # Latest theme assets checksums. Updated on each upload.
+        @checksums = Checksums.new(theme)
+
+        # Checksums of assets with errors.
+        @error_checksums = []
+
+        # Do not use the throttler when --stable is passed or a Theme Access password is set
+        # (Theme Access API is not compatible yet with bulks)
+        @bulk_updates_activated = !stable && !Environment.theme_access_password?
+
+        # Initialize `api_client` on main thread
+        @api_client = ThemeAdminAPI.new(ctx, theme.shop)
+
+        # Initialize backoff helper on main thread to pause all threads when the
+        # requests are reaching API rate limits.
+        initialize_backoff_helper!
+      end
+
+      def lock_io!
+        @reporters.each(&:disable!)
+      end
+
+      def unlock_io!
+        @reporters.each(&:enable!)
+      end
+
+      def enqueue_updates(files)
+        files.each { |file| enqueue(:update, file) }
+      end
+
+      def enqueue_get(files)
+        files.each { |file| enqueue(:get, file) }
+      end
+
+      def enqueue_deletes(files)
+        files.each { |file| enqueue(:delete, file) }
+      end
+
+      def enqueue_union_merges(files)
+        files.each { |file| enqueue(:union_merge, file) }
+      end
+
+      def size
+        @pending.size
+      end
+
+      def empty?
+        @pending.empty?
+      end
+
+      def pending_updates
+        @pending.select { |op| op.method == :update }.map(&:file)
+      end
+
+      def remote_file?(file)
+        checksums.has?(file)
+      end
+
+      def broken_file?(file)
+        error_checksums.include?(checksums[file.relative_path])
+      end
+
+      def wait!
+        raise ThreadError, "No syncer threads" if @threads.empty?
+
+        total = size
+        last_size = size
+        until empty? || @queue.closed?
+          if block_given? && last_size != size
+            yield size, total
+            last_size = size
+          end
+          Thread.pass
+        end
+      end
+
+      def fetch_checksums!
+        _status, response = api_client.get(
+          path: "themes/#{@theme.id}/assets.json",
+        )
+        update_checksums(response)
+      end
+
+      def shutdown
+        @queue.close unless @queue.closed?
+      ensure
+        @threads.each { |thread| thread.join if thread.alive? }
+      end
+
+      def start_threads(count = 2)
+        count.times do
+          @threads << Thread.new do
+            loop do
+              operation = @queue.pop
+              break if operation.nil? # shutdown was called
+
+              perform(operation)
+            rescue Exception => e # rubocop:disable Lint/RescueException
+              error_suffix = ": #{e}"
+              error_suffix += + "\n\t#{e.backtrace.join("\n\t")}" if @ctx.debug?
+              report_error(operation, error_suffix)
+            end
+          end
+        end
+      end
+
+      def upload_theme!(delay_low_priority_files: false, delete: true, &block)
+        uploader = Uploader.new(self, delete, delay_low_priority_files, &block)
+        uploader.upload!
+      end
+
+      def download_theme!(delete: true, &block)
+        downloader = Downloader.new(self, delete, &block)
+        downloader.download!
+      end
+
+      def bulk_updates_activated?
+        @bulk_updates_activated
+      end
+
+      def enqueueable?(operation)
+        file = operation.file
+        method = operation.method
+
+        # Already enqueued or ignored
+        return false if @pending.include?(operation) || ignore_operation?(operation)
+
+        if [:update, :get].include?(method) && file.exist?
+          # File is fixed (and it has been never updated)
+          if !!@error_checksums.delete(file.checksum)
+            @standard_reporter.report(operation.as_fix_message)
+          end
+
+          return checksums.file_has_changed?(file)
+        end
+
+        true
+      end
+
+      def handle_operation_error(operation, error)
+        error_suffix = ":\n  " + parse_api_errors(operation.file, error).join("\n  ")
+        report_error(operation, error_suffix)
+      end
+
+      def overwrite_json?
+        theme_created_at_runtime? || @overwrite_json
+      end
+
+      def update_checksums(api_response)
+        api_response.values.flatten.each do |asset|
+          next unless asset["key"]
+
+          checksums[asset["key"]] = asset["checksum"]
+        end
+
+        checksums.reject_duplicated_checksums!
+      end
+
+      def report_file_error(file, error_message = "")
+        path = file.relative_path
+
+        @error_checksums << checksums[path]
+        @error_reporter.report(error_message)
+      end
+
+      def parse_api_errors(file, exception)
+        parsed_body = {}
+
+        if exception.respond_to?(:response)
+          response = exception.response
+
+          parsed_body = if response&.is_a?(Hash)
+            response&.[](:body)
+          else
+            JSON.parse(response&.body)
+          end
+        end
+
+        errors = parsed_body.dig("errors") # either nil or another type
+        errors = errors.dig("asset") if errors&.is_a?(Hash)
+
+        message = errors || parsed_body["message"] || exception.message
+        # Truncate to first lines
+        [message].flatten.map { |m| m.split("\n", 2).first }
+      rescue JSON::ParserError
+        [exception.message]
+      rescue StandardError => e
+        cause = "(cause: #{e.message})"
+        backtrace = e.backtrace.join("\n")
+        ["The asset #{file} could not be synced #{cause} #{backtrace}"]
+      end
+
+      private
+
+      def report_error(operation, error_suffix = "")
+        file = operation.file
+        error_message = "#{operation.as_error_message}#{error_suffix}"
+
+        report_file_error(file, error_message)
+      end
+
+      def enqueue(method, file)
+        raise ArgumentError, "file required" unless file
+        raise ArgumentError, "method '#{method}' cannot be queued" unless QUEUEABLE_METHODS.include?(method)
+
+        operation = Operation.new(@ctx, method, @theme[file])
+
+        return unless enqueueable?(operation)
+
+        @pending << operation
+        @queue << operation unless @queue.closed?
+      end
+
+      def report_performed_operation(operation)
+        file = operation.file
+
+        if file.warnings.any?
+          warning_message =
+            operation.as_synced_message(color: :yellow) +
+            UnsupportedScriptWarning.new(@ctx, file).to_s
+
+          return @error_reporter.report(warning_message)
+        end
+
+        @standard_reporter.report(operation.as_synced_message)
+      end
+
+      def perform(operation)
+        return if @queue.closed?
+
+        wait_for_backoff!
+        @ctx.debug(operation.to_s)
+
+        response = send(operation.method, operation.file)
+
+        report_performed_operation(operation)
+        backoff_if_near_limit!(response)
+      rescue StandardError => error
+        handle_operation_error(operation, error)
+      ensure
+        @pending.delete(operation)
+      end
+
+      def update(file)
+        asset = { key: file.relative_path }
+
+        if file.text?
+          asset[:value] = file.read
+        else
+          asset[:attachment] = Base64.encode64(file.read)
+        end
+
+        path = "themes/#{@theme.id}/assets.json"
+
+        _status, body, response = api_client.put(
+          path: path,
+          body: JSON.generate(asset: asset),
+        )
+        file.warnings = body.dig("asset", "warnings")
+
+        update_checksums(body)
+
+        response
+      end
+
+      def get(file)
+        _status, body, response = api_client.get(
+          path: "themes/#{@theme.id}/assets.json",
+          query: URI.encode_www_form("asset[key]" => file.relative_path),
+        )
+
+        update_checksums(body)
+
+        attachment = body.dig("asset", "attachment")
+        if attachment
+          file.write(Base64.decode64(attachment))
+        else
+          file.write(body.dig("asset", "value"))
+        end
+
+        response
+      end
+
+      def delete(file)
+        _status, _body, response = api_client.delete(
+          path: "themes/#{@theme.id}/assets.json",
+          body: JSON.generate(asset: {
+            key: file.relative_path,
+          }),
+        )
+
+        checksums.delete(file) if checksums.has?(file)
+
+        response
+      end
+
+      def union_merge(file)
+        _status, body, response = api_client.get(
+          path: "themes/#{@theme.id}/assets.json",
+          query: URI.encode_www_form("asset[key]" => file.relative_path),
+        )
+
+        return response unless file.text?
+
+        remote_content = body.dig("asset", "value")
+
+        return response if remote_content.nil?
+
+        content = Merger.union_merge(file, remote_content)
+
+        file.write(content)
+
+        enqueue(:update, file)
+
+        response
+      end
+
+      def theme_created_at_runtime?
+        @theme.created_at_runtime?
+      end
+
+      def wait(duration)
+        sleep(duration)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,212 @@
+# frozen_string_literal: true
+require_relative "file"
+require_relative "root"
+require_relative "theme_admin_api"
+
+require "pathname"
+require "time"
+
+module ShopifyCLI
+  module Theme
+    class InvalidThemeRole < StandardError; end
+
+    class Theme < Root
+      attr_reader :root, :id
+
+      def initialize(ctx, root: nil, id: nil, name: nil, role: nil)
+        super(ctx, root: root)
+        @id = id
+        @name = name
+        @role = role
+      end
+
+      def theme_files
+        (glob(["**/*.liquid", "**/*.json"]) + static_asset_files).uniq
+      end
+
+      def theme_file?(file)
+        theme_files.include?(self[file])
+      end
+
+      def shop
+        api_client.get_shop_or_abort
+      end
+
+      def editor_url
+        "https://#{shop}/admin/themes/#{id}/editor"
+      end
+
+      def name
+        return @name if @name
+        load_info_from_api.name
+      end
+
+      def role
+        if @role == "main"
+          # Main theme is called Live in UI
+          "live"
+        elsif @role
+          @role
+        else
+          load_info_from_api.role
+        end
+      end
+
+      def live?
+        role == "live"
+      end
+
+      def development?
+        role == "development"
+      end
+
+      def preview_url
+        if live?
+          "https://#{shop}/"
+        else
+          "https://#{shop}/?preview_theme_id=#{id}"
+        end
+      end
+
+      def create
+        raise InvalidThemeRole, "Can't create live theme. Use publish." if live?
+
+        _status, body = api_client.post(
+          path: "themes.json",
+          body: JSON.generate({
+            theme: {
+              name: name,
+              role: role,
+            },
+          }),
+        )
+
+        @id = body["theme"]["id"]
+        @created_at_runtime = true
+      end
+
+      def delete
+        delete_theme
+      end
+
+      def publish
+        return if live?
+        api_client.put(
+          path: "themes/#{id}.json",
+          body: JSON.generate(theme: {
+            role: "main",
+          })
+        )
+        @role = "live"
+      end
+
+      def current_development?
+        development? && id == ShopifyCLI::DB.get(:development_theme_id)
+      end
+
+      def foreign_development?
+        development? && id != ShopifyCLI::DB.get(:development_theme_id)
+      end
+
+      def created_at_runtime?
+        @created_at_runtime ||= false
+      end
+
+      def to_h
+        {
+          id: id,
+          name: name,
+          role: role,
+          shop: shop,
+          editor_url: editor_url,
+          preview_url: preview_url,
+        }
+      end
+
+      class << self
+        def create_unpublished(ctx, root: nil, name: nil)
+          name ||= random_name
+          theme = new(ctx, root: root, name: name, role: "unpublished")
+          theme.create
+          theme
+        end
+
+        def all(ctx, root: nil)
+          _status, body = fetch_themes(ctx)
+
+          body["themes"]
+            .sort_by { |theme_attrs| Time.parse(theme_attrs["updated_at"]) }
+            .reverse
+            .map { |theme_attrs| new(ctx, root: root, **allowed_attrs(theme_attrs)) }
+        end
+
+        def live(ctx, root: nil)
+          find(ctx, root) { |attrs| attrs["role"] == "main" }
+        end
+
+        # Finds a Theme by its identifier
+        #
+        # #### Parameters
+        # * `ctx` - current running context of your command
+        # * `root` - theme root
+        # * `identifier` - theme ID or theme name
+        def find_by_identifier(ctx, root: nil, identifier:)
+          find(ctx, root) do |attrs|
+            attrs.slice("name", "id").values.map(&:to_s).include?(identifier)
+          end
+        end
+
+        private
+
+        def random_name
+          ShopifyCLI::Helpers::Haikunator.haikunate(9999)
+        end
+
+        def find(ctx, root, &block)
+          _status, body = fetch_themes(ctx)
+
+          body["themes"]
+            .find(&block)
+            .tap do |attrs|
+              break new(ctx, root: root, **allowed_attrs(attrs)) if attrs
+            end
+        end
+
+        def allowed_attrs(attrs)
+          attrs.slice("id", "name", "role").transform_keys(&:to_sym)
+        end
+
+        def fetch_themes(ctx)
+          api_client = ThemeAdminAPI.new(ctx)
+
+          api_client.get(
+            path: "themes.json"
+          )
+        end
+      end
+
+      private
+
+      def api_client
+        @api_client ||= ThemeAdminAPI.new(@ctx)
+      end
+
+      def delete_theme
+        api_client.delete(
+          path: "themes/#{id}.json"
+        )
+      end
+
+      def load_info_from_api
+        _status, body = api_client.get(
+          path: "themes/#{id}.json"
+        )
+
+        @name = body.dig("theme", "name")
+        @role = body.dig("theme", "role")
+
+        self
+      end
+    end
+  end
+end

package/assets/cli-ruby/lib/shopify_cli/theme/theme_access_api.rb

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+require "shopify_cli"
+
+module ShopifyCLI
+  module Theme
+    ##
+    # ShopifyCLI::ThemeAccessAPI is a wrapper to use Shopify Theme Access API, which allows using passwords
+    # generated from Shopify Theme Access app to access the Shopify Admin API (for theme operations)
+    #
+    class ThemeAccessAPI < API
+      BASE_URL = "theme-kit-access.shopifyapps.com"
+
+      class << self
+        ##
+        # #### Parameters
+        # - `ctx`: running context from your command
+        # - `shop`: shop domain string for shop whose admin you are calling
+        # - `path`: path string (excluding prefixes and API version) for specific JSON that you are requesting
+        #     ex. "data.json" instead of "/admin/api/unstable/data.json"
+        # - `body`: data string for corresponding REST request types
+        # - `method`: REST request string for the type of request; if nil, will perform GET request
+        # - `api_version`: an api version string to specify version. Default value: unstable
+        #
+        # #### Raises
+        #
+        # * http 404 will raise a ShopifyCLI::API::APIRequestNotFoundError
+        # * http 400..499 will raise a ShopifyCLI::API::APIRequestClientError
+        # * http 500..599 will raise a ShopifyCLI::API::APIRequestServerError
+        # * All other codes will raise ShopifyCLI::API::APIRequestUnexpectedError
+        #
+        # #### Returns
+        #
+        # * `resp` - JSON response array
+        #
+        # #### Example
+        #
+        #   ThemeAccessAPI.rest_request(@ctx, shop: 'shop.myshopify.com', path: 'data.json')
+        #
+        def rest_request(ctx, shop:, path:, query: nil, body: nil, method: "GET", api_version: "unstable")
+          client = api_client(ctx, api_version, shop, path: path)
+          url = build_url(api_version, path, query)
+          client.request(url: url, body: body, headers: headers(shop), method: method)
+        rescue ShopifyCLI::API::APIRequestForbiddenError,
+               ShopifyCLI::API::APIRequestUnauthorizedError
+          ctx.abort(ctx.message("core.api.error.theme_access_invalid_password"))
+        end
+
+        def get_shop_or_abort(ctx)
+          env_store = Environment.store
+          return env_store unless env_store.nil?
+          ctx.abort(
+            ctx.message("core.api.error.theme_access_no_store")
+          )
+        end
+
+        private
+
+        def build_url(api_version, path, query = nil)
+          URI::HTTPS.build(
+            host: BASE_URL,
+            path: "/cli/admin/api/#{api_version}/#{path}",
+            query: query
+          ).to_s
+        end
+
+        def api_client(ctx, api_version, _shop, path: "graphql.json")
+          new(
+            ctx: ctx,
+            token: Environment.admin_auth_token,
+            url: build_url(api_version, path),
+          )
+        end
+
+        def headers(shop)
+          {
+            "X-Shopify-Shop" => shop,
+          }
+        end
+      end
+
+      def auth_headers(token)
+        {
+          "X-Shopify-Access-Token" => token,
+        }
+      end
+    end
+  end
+end