@shopify/cli-kit 3.69.3 → 3.70.0

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

@@ -1,212 +0,0 @@
-# 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
-
-        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
-
-        private
-
-        def random_name
-          ShopifyCLI::Helpers::Haikunator.haikunate(9999)
-        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

@@ -1,89 +0,0 @@
-# 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
-      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)
-          domain = Environment.theme_kit_access_domain
-
-          URI::HTTPS.build(
-            host: domain,
-            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

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

@@ -1,101 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "theme_access_api"
-
-module ShopifyCLI
-  module Theme
-    class ThemeAdminAPI
-      API_VERSION = "unstable"
-
-      attr_reader :shop
-
-      def initialize(ctx, shop = nil)
-        @ctx = ctx
-        @shop = shop || get_shop_or_abort
-      end
-
-      def get(path:, **args, &block)
-        rest_request(method: "GET", path: path, **args, &block)
-      end
-
-      def put(path:, **args, &block)
-        rest_request(method: "PUT", path: path, **args, &block)
-      end
-
-      def post(path:, **args, &block)
-        rest_request(method: "POST", path: path, **args, &block)
-      end
-
-      def delete(path:, **args, &block)
-        rest_request(method: "DELETE", path: path, **args, &block)
-      end
-
-      def get_shop_or_abort # rubocop:disable Naming/AccessorMethodName
-        api_client.get_shop_or_abort(@ctx)
-      end
-
-      def rest_request(**args)
-        status, body, response = api_client.rest_request(
-          @ctx,
-          shop: @shop,
-          api_version: API_VERSION,
-          **args.compact
-        )
-        return yield(status, body, response) if block_given?
-
-        [status, body, response]
-      rescue ShopifyCLI::API::APIRequestForbiddenError,
-             ShopifyCLI::API::APIRequestUnauthorizedError => error
-
-        ##
-        # The Admin API returns 403 Forbidden responses on different
-        # scenarios:
-        #
-        # * when a user doesn't have permissions for a request:
-        #   - <APIRequestForbiddenError: 403 {}>
-        #   - <APIRequestForbiddenError: 403 {"errors":"Unauthorized Access"}>
-        #
-        # * when an asset operation cannot be performed:
-        #   - <APIRequestForbiddenError: 403 {"message":"templates/gift_card.liquid could not be deleted"}>
-        #
-        if empty_response?(error)
-          return permission_error
-        elsif unauthorized_response?(error)
-          @ctx.debug("[#{self.class}] (#{error.class}) cause: #{response_body(error)}")
-          raise ShopifyCLI::Abort, @ctx.message("theme.unauthorized_error", @shop)
-        end
-
-        raise error
-      end
-
-      private
-
-      def api_client
-        @api_client ||= Environment.theme_access_password? ? ThemeAccessAPI : ShopifyCLI::AdminAPI
-      end
-
-      def permission_error
-        ensure_user_error = @ctx.message("theme.ensure_user_error", shop)
-        ensure_user_try_this = @ctx.message("theme.ensure_user_try_this")
-
-        @ctx.abort(ensure_user_error, ensure_user_try_this)
-      end
-
-      def empty_response?(error)
-        response_body(error).empty?
-      end
-
-      def unauthorized_response?(error)
-        parsed_body = JSON.parse(response_body(error))
-        errors = parsed_body["errors"].to_s
-        errors.match?(/Unauthorized Access/)
-      rescue JSON::ParserError
-        false
-      end
-
-      def response_body(error)
-        error&.response&.body.to_s
-      end
-    end
-  end
-end

package/assets/cli-ruby/lib/shopify_cli/thread_pool/job.rb

@@ -1,35 +0,0 @@
-# frozen_string_literal: true
-
-module ShopifyCLI
-  class ThreadPool
-    class Job
-      attr_reader :error, :interval
-
-      def initialize(interval = 0)
-        @interval = interval
-      end
-
-      def perform!
-        raise "`#{self.class.name}#perform!' must be defined"
-      end
-
-      def call
-        perform!
-      rescue StandardError => error
-        @error = error
-      end
-
-      def success?
-        !@error
-      end
-
-      def error?
-        !!@error
-      end
-
-      def recurring?
-        !interval.zero?
-      end
-    end
-  end
-end

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

@@ -1,49 +0,0 @@
-# frozen_string_literal: true
-
-module ShopifyCLI
-  class ThreadPool
-    attr_reader :errors
-
-    def initialize(pool_size: 10)
-      @jobs = Queue.new
-      @pool = Array.new(pool_size) { spawn_thread }
-    end
-
-    def schedule(job)
-      @jobs << job
-    end
-
-    def shutdown
-      @pool.size.times do
-        schedule(-> { throw(:stop_thread) })
-      end
-      @pool.map(&:join)
-    ensure
-      @jobs.close
-    end
-
-    private
-
-    def spawn_thread
-      Thread.new do
-        catch(:stop_thread) do
-          loop { perform(@jobs.pop) }
-        end
-      end
-    end
-
-    def perform(job)
-      job.call
-      reschedule(job) if job.recurring?
-    end
-
-    def reschedule(job)
-      wait(job.interval)
-      schedule(job)
-    end
-
-    def wait(seconds)
-      sleep(seconds)
-    end
-  end
-end

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

@@ -1,87 +0,0 @@
-
-module ShopifyCLI
-  ##
-  # `TransformDataStructure` helps to standardize data structure access. It
-  # traverses nested data structures and can convert
-  #
-  # * all strings used as keys to symbols,
-  # * all strings used as keys from `CamelCase` to `snake_case` and
-  # * associative array containers, e.g. from Hash to OpenStruct.
-  #
-  # Standardizing how a data structure is accessed greatly reduces the risk
-  # of subtle bugs especially when dealing with API responses.
-  #
-  #    TransformDataStructure.new(
-  #      symbolize_keys: true,
-  #      underscore_keys: true,
-  #      associative_array_container: OpenStruct
-  #    ).call([{"SomeKey" => "value"}]).tap do |result|
-  #      result.value # => [#<OpenStruct: some_key: "value">]
-  #    end
-  #
-  # Since `TransformDataStructure` is a method object, it can easily be chained:
-  #
-  #    require 'open-uri'
-  #    ShopifyCLI::Result
-  #      .call { open("https://jsonplaceholder.typicode.com/todos/1") }
-  #      .map(&TransformDataStructure.new(symbolize_keys: true, underscore_keys: true))
-  #      .value # => { id: 1, user_id: 1, ... }
-  #
-  class TransformDataStructure
-    include ShopifyCLI::MethodObject
-
-    class << self
-      private
-
-      def valid_associative_array_container(klass)
-        klass.respond_to?(:new) && klass.method_defined?(:[]=)
-      end
-    end
-
-    property! :underscore_keys, accepts: [true, false], default: false, reader: :underscore_keys?
-    property! :symbolize_keys, accepts: [true, false], default: false, reader: :symbolize_keys?
-    property! :shallow, accepts: [true, false], default: false, reader: :shallow?
-    property! :associative_array_container,
-      accepts: ->(c) { c.respond_to?(:new) && c.method_defined?(:[]=) },
-      default: -> { Hash }
-
-    def call(object)
-      case object
-      when Array
-        shallow? ? object.dup : object.map(&self).map(&:value)
-      when Hash
-        object.each.with_object(associative_array_container.new) do |(key, value), result|
-          result[transform_key(key)] = shallow? ? value : call(value).value
-        end
-      else
-        ShopifyCLI::Result.success(object)
-      end
-    end
-
-    private
-
-    def transform_key(key)
-      key
-        .yield_self(&method(:underscore_key))
-        .yield_self(&method(:symbolize_key))
-    end
-
-    def underscore_key(key)
-      return key unless underscore_keys? && key.respond_to?(:to_str)
-
-      key.to_str.dup.tap do |k|
-        k.gsub!(/([A-Z\d]+)([A-Z][a-z])/, '\1_\2')
-        k.gsub!(/([a-z\d])([A-Z])/, '\1_\2')
-        k.tr!("-", "_")
-        k.gsub!(/\s/, "_")
-        k.gsub!(/__+/, "_")
-        k.downcase!
-      end
-    end
-
-    def symbolize_key(key)
-      return key unless symbolize_keys? && key.respond_to?(:to_sym)
-      key.to_sym
-    end
-  end
-end

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

@@ -1,21 +0,0 @@
-module ShopifyCLI
-  module Utilities
-    def self.version_dropping_pre_and_build(version)
-      Semantic::Version.new("#{version.major}.#{version.minor}.#{version.patch}")
-    end
-
-    def self.directory(pattern, curr)
-      loop do
-        return nil if curr == "/" || /^[A-Z]:\/$/.match?(curr)
-        file = File.join(curr, pattern)
-        return curr if File.exist?(file)
-        curr = File.dirname(curr)
-      end
-    end
-
-    def self.deep_merge(first, second)
-      merger = proc { |_key, v1, v2| Hash === v1 && Hash === v2 ? v1.merge(v2, &merger) : v2 }
-      first.merge(second, &merger)
-    end
-  end
-end

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

@@ -1,3 +0,0 @@
-module ShopifyCLI
-  VERSION = ENV.fetch("SHOPIFY_CLI_VERSION", "3.46.0")
-end