@shopify/cli-kit 3.69.3 → 3.70.0

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

@@ -1,160 +0,0 @@
-require "shopify_cli"
-
-module ShopifyCLI
-  ##
-  # ShopifyCLI::AdminAPI wraps our graphql functionality with authentication so that
-  # these concerns are taken care of.
-  #
-  class AdminAPI < API
-    class << self
-      ##
-      # issues a graphql query or mutation to the Shopify Admin API. It loads a graphql
-      # query from a file so that you do not need to use large unwieldy query strings.
-      #
-      # #### Parameters
-      # - `ctx`: running context from your command
-      # - `query_name`: name of the query you want to use, loaded from the `lib/graphql` directory.
-      # - `api_version`: an api version string to specify version. If no version is supplied then unstable will be used
-      # - `shop`: shop domain string for which shop that you are calling the admin
-      #   API on. If not supplied, then it will be fetched from the `.env` file
-      # - `**variable`: a hash of variables to be supplied to the query ro mutation
-      #
-      # #### 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` - graphql response data hash. This can be a different shape for every query.
-      #
-      # #### Example
-      #
-      #   ShopifyCLI::AdminAPI.query(@ctx, 'all_organizations')
-      #
-      def query(ctx, query_name, shop:, api_version: nil, **variables)
-        CLI::Kit::Util.begin do
-          api_client(ctx, api_version, shop).query(query_name, variables: variables)
-        end.retry_after(API::APIRequestUnauthorizedError, retries: 1) do
-          ShopifyCLI::IdentityAuth.new(ctx: ctx).reauthenticate
-        end
-      rescue API::APIRequestUnauthorizedError
-        ctx.abort(ctx.message("core.api.error.failed_auth"))
-      rescue API::APIRequestForbiddenError
-        ctx.abort(ctx.message("core.api.error.forbidden", ShopifyCLI::TOOL_NAME))
-      end
-
-      ##
-      #
-      #
-      #
-      # #### 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`: API version string to specify version; if nil, latest will be used
-      # - `token`: shop password string for authentication to shop
-      #
-      # #### 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
-      #
-      #   ShopifyCLI::AdminAPI.rest_request(@ctx,
-      #                                     shop: 'shop.myshopify.com',
-      #                                     path: 'data.json',
-      #                                     token: 'password')
-      #
-      def rest_request(ctx, shop:, path:, query: nil, body: nil, method: "GET", api_version: nil, token: nil)
-        CLI::Kit::Util.begin do
-          ShopifyCLI::DB.set(shopify_exchange_token: token) unless token.nil?
-          url = URI::HTTPS.build(
-            host: shop,
-            path: "/admin/api/#{fetch_api_version(ctx, api_version, shop)}/#{path}",
-            query: query,
-          )
-          resp = api_client(ctx, api_version, shop, path: path).request(url: url.to_s, body: body, method: method)
-          ShopifyCLI::DB.set(shopify_exchange_token: nil) unless token.nil?
-          resp
-        end.retry_after(API::APIRequestUnauthorizedError) do
-          ShopifyCLI::IdentityAuth.new(ctx: ctx).reauthenticate
-        end
-      end
-
-      def get_shop_or_abort(ctx)
-        env_store = Environment.store
-        return env_store unless env_store.nil?
-        ctx.abort(
-          ctx.message("core.populate.error.no_shop", ShopifyCLI::TOOL_NAME)
-        ) unless ShopifyCLI::DB.exists?(:shop)
-        ShopifyCLI::DB.get(:shop)
-      end
-
-      private
-
-      def authenticate(ctx, _shop)
-        ShopifyCLI::IdentityAuth.new(ctx: ctx).authenticate
-      end
-
-      def api_client(ctx, api_version, shop, path: "graphql.json")
-        new(
-          ctx: ctx,
-          token: access_token(ctx, shop),
-          url: "https://#{shop}/admin/api/#{fetch_api_version(ctx, api_version, shop)}/#{path}",
-        )
-      end
-
-      def access_token(ctx, shop)
-        env_token = Environment.admin_auth_token
-        env_token || ShopifyCLI::DB.get(:shopify_exchange_token) do
-          authenticate(ctx, shop)
-          ShopifyCLI::DB.get(:shopify_exchange_token)
-        end
-      end
-
-      def fetch_api_version(ctx, api_version, shop)
-        return api_version unless api_version.nil?
-        client = new(
-          ctx: ctx,
-          token: access_token(ctx, shop),
-          url: "https://#{shop}/admin/api/unstable/graphql.json",
-        )
-        CLI::Kit::Util.begin do
-          versions = client.query("api_versions")["data"]["publicApiVersions"]
-          # return the most recent supported version
-          versions
-            .select { |version| version["supported"] }
-            .map { |version| version["handle"] }
-            .sort
-            .reverse[0]
-        end.retry_after(API::APIRequestUnauthorizedError, retries: 1) do
-          ShopifyCLI::IdentityAuth.new(ctx: ctx).reauthenticate
-        end
-      rescue API::APIRequestUnauthorizedError
-        ctx.abort(ctx.message("core.api.error.failed_auth"))
-      rescue API::APIRequestForbiddenError
-        ctx.abort(ctx.message("core.api.error.forbidden", ShopifyCLI::TOOL_NAME))
-      end
-    end
-
-    def auth_headers(token)
-      {
-        Authorization: "Bearer #{token}",
-        "X-Shopify-Access-Token" => token,
-      }
-    end
-  end
-end

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

@@ -1,130 +0,0 @@
-require "shopify_cli"
-require "securerandom"
-
-module ShopifyCLI
-  class API
-    include SmartProperties
-
-    property! :ctx, accepts: ShopifyCLI::Context
-    property! :token, accepts: String
-    property :auth_header, accepts: String
-    property! :url, accepts: String
-
-    class APIRequestError < StandardError
-      attr_reader :response
-
-      def initialize(message = nil, response: nil)
-        super(message)
-        @response = response
-      end
-    end
-
-    class APIRequestNotFoundError < APIRequestError; end
-    class APIRequestClientError < APIRequestError; end
-    class APIRequestUnauthorizedError < APIRequestClientError; end
-    class APIRequestForbiddenError < APIRequestClientError; end
-    class APIRequestUnexpectedError < APIRequestError; end
-    class APIRequestRetriableError < APIRequestError; end
-    class APIRequestTimeoutError < APIRequestRetriableError; end
-    class APIRequestServerError < APIRequestRetriableError; end
-    class APIRequestThrottledError < APIRequestRetriableError; end
-
-    def self.gid_to_id(gid)
-      gid.split("/").last
-    end
-
-    def query(query_name, variables: {})
-      _, resp = request(
-        body: JSON.dump(query: load_query(query_name).tr("\n", ""), variables: variables),
-        url: url,
-      )
-      ctx.debug(resp)
-      resp
-    rescue API::APIRequestServerError, API::APIRequestUnexpectedError => e
-      ctx.puts(ctx.message("core.api.error.internal_server_error"))
-      ctx.debug(ctx.message("core.api.error.internal_server_error_debug", e.message))
-    end
-
-    def request(url:, body: nil, headers: {}, method: "POST")
-      CLI::Kit::Util.begin do
-        uri = URI.parse(url)
-        unless uri.is_a?(URI::HTTP)
-          ctx.abort(ctx.message("core.api.error.invalid_url", url))
-        end
-
-        # we delay this require so as to avoid a performance hit on starting the CLI
-        require "shopify_cli/http_request"
-        headers = default_headers.merge(headers)
-        response = if method == "POST"
-          HttpRequest.post(uri, body, headers)
-        elsif method == "PUT"
-          HttpRequest.put(uri, body, headers)
-        elsif method == "GET"
-          HttpRequest.get(uri, body, headers)
-        elsif method == "DELETE"
-          HttpRequest.delete(uri, body, headers)
-        end
-        ctx.debug("#{method} #{uri} with request_id: #{response["x-request-id"]}")
-        case response.code.to_i
-        when 200..399
-          [response.code.to_i, JSON.parse(response.body), response]
-        when 401
-          raise APIRequestUnauthorizedError.new("#{response.code}\n#{response.body}", response: response)
-        when 403
-          raise APIRequestForbiddenError.new("#{response.code}\n#{response.body}", response: response)
-        when 404
-          raise APIRequestNotFoundError.new("#{response.code}\n#{response.body}", response: response)
-        when 429
-          raise APIRequestThrottledError.new("#{response.code}\n#{response.body}", response: response)
-        when 400..499
-          raise APIRequestClientError.new("#{response.code}\n#{response.body}", response: response)
-        when 500..599
-          raise APIRequestServerError.new("#{response.code}\n#{response.body}", response: response)
-        else
-          raise APIRequestUnexpectedError.new("#{response.code}\n#{response.body}", response: response)
-        end
-      rescue Errno::ETIMEDOUT, Timeout::Error
-        ctx.debug("timeout in #{method} #{uri}")
-        raise APIRequestTimeoutError, "Timeout"
-      end.retry_after(APIRequestRetriableError, retries: 3) do |e|
-        sleep(1) if e.is_a?(APIRequestThrottledError)
-      end
-    end
-
-    protected
-
-    def load_query(name)
-      project_type = ShopifyCLI::Project.current_project_type
-      project_file_path = File.join(
-        ShopifyCLI::ROOT, "lib", "project_types", project_type.to_s, "graphql", "#{name}.graphql"
-      )
-      if !project_type.nil? && File.exist?(project_file_path)
-        File.read(project_file_path)
-      else
-        File.read(File.join(ShopifyCLI::ROOT, "lib", "graphql", "#{name}.graphql"))
-      end
-    end
-
-    private
-
-    def default_headers
-      sha = ShopifyCLI.sha
-      user_agent = "Shopify CLI; v=#{ShopifyCLI::VERSION}"
-      sec_ch_ua = user_agent
-      sec_ch_ua += " sha=#{sha}" unless sha.nil?
-
-      {
-        "User-Agent" => user_agent,
-        "Sec-CH-UA" => sec_ch_ua,
-        "Sec-CH-UA-PLATFORM" => ctx.os.to_s,
-      }.tap do |headers|
-        headers["X-Shopify-Cli-Employee"] = "1" if Shopifolk.acting_as_shopify_organization?
-      end.merge(auth_headers(token))
-    end
-
-    def auth_headers(token)
-      raise NotImplementedError if auth_header.nil?
-      { auth_header => token }
-    end
-  end
-end

package/assets/cli-ruby/lib/shopify_cli/command/project_command.rb

@@ -1,31 +0,0 @@
-module ShopifyCLI
-  class Command
-    class ProjectCommand < Command
-      def call(*)
-        @ctx.puts(self.class.help)
-      end
-
-      class << self
-        def help
-          project_type = name.split("::")[0].downcase
-          ShopifyCLI::Context.message(
-            "#{project_type}.help",
-            ShopifyCLI::TOOL_NAME,
-            available_subcommands
-          )
-        end
-
-        private
-
-        def available_subcommands
-          subcommand_registry
-            .resolved_commands
-            .reject { |_name, command| command.hidden? }
-            .keys
-            .sort
-            .join(" | ")
-        end
-      end
-    end
-  end
-end

package/assets/cli-ruby/lib/shopify_cli/command/sub_command.rb

@@ -1,20 +0,0 @@
-# frozen_string_literal: true
-require "shopify_cli"
-
-module ShopifyCLI
-  class Command
-    class SubCommand < Command
-      class << self
-        def call(args, command_name, _parent_command)
-          cmd = new(@ctx)
-          args = cmd.options.parse(@_options, args || [])
-          check_ruby_version
-          check_node_version
-          run_prerequisites
-
-          cmd.call(args, command_name)
-        end
-      end
-    end
-  end
-end

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

@@ -1,166 +0,0 @@
-# frozen_string_literal: true
-require "shopify_cli"
-require "semantic/semantic"
-
-module ShopifyCLI
-  class Command < CLI::Kit::BaseCommand
-    autoload :SubCommand,     "shopify_cli/command/sub_command"
-    autoload :ProjectCommand, "shopify_cli/command/project_command"
-
-    VersionRange = Struct.new(:from, :to, keyword_init: true)
-
-    extend Feature::Set
-
-    attr_writer :ctx
-    attr_accessor :options
-
-    class << self
-      attr_writer :ctx, :task_registry
-
-      def call(args, command_name, *)
-        subcommand, resolved_name = subcommand_registry.lookup_command(args.first)
-        if subcommand
-          subcommand.ctx = @ctx
-          subcommand.task_registry = @task_registry
-
-          subcommand.call(args.drop(1), resolved_name, command_name)
-        else
-          cmd = new(@ctx)
-          cmd.options.parse(@_options, args)
-          check_ruby_version
-          check_node_version
-          run_prerequisites
-          cmd.call(args, command_name)
-        end
-      rescue OptionParser::InvalidOption => error
-        arg = error.args.first
-        store_name = arg.match(/\A--(?<store_name>.*\.myshopify\.com)\z/)&.[](:store_name)
-        if store_name && !arg.match?(/\A--(store|shop)=/)
-          # Sometimes it may look like --invalidoption=https://storename.myshopify.com
-          store_name = store_name.sub(%r{\A(.*=)?(https?://)?}, "")
-          raise ShopifyCLI::Abort,
-            @ctx.message("core.errors.option_parser.invalid_option_store_equals", arg, store_name)
-        end
-        raise ShopifyCLI::Abort, @ctx.message("core.errors.option_parser.invalid_option", arg)
-      rescue OptionParser::MissingArgument => error
-        arg = error.args.first
-        raise ShopifyCLI::Abort, @ctx.message("core.errors.option_parser.missing_argument", arg)
-      end
-
-      def options(&block)
-        existing_options = @_options
-        # We prevent new options calls to override existing blocks by nesting them.
-        @_options = ->(parser, flags) {
-          existing_options&.call(parser, flags)
-          block.call(parser, flags)
-        }
-      end
-
-      def subcommand(const, cmd, path = nil)
-        autoload(const, path) if path
-        subcommand_registry.add(->() { const_get(const) }, cmd.to_s)
-      end
-
-      def subcommand_registry
-        @subcommand_registry ||= CLI::Kit::CommandRegistry.new(
-          default: nil,
-          contextual_resolver: nil,
-        )
-      end
-
-      def recommend_ruby(from:, to:)
-        @compatible_ruby_range = VersionRange.new(
-          from: Semantic::Version.new(from),
-          to: Semantic::Version.new(to)
-        )
-      end
-
-      def recommend_default_ruby_range
-        recommend_ruby(
-          from: Constants::SupportedVersions::Ruby::FROM,
-          to: Constants::SupportedVersions::Ruby::TO
-        )
-      end
-
-      def check_ruby_version
-        check_version(
-          Environment.ruby_version,
-          range: @compatible_ruby_range,
-          runtime: "Ruby"
-        )
-      end
-
-      def recommend_node(from:, to:)
-        @compatible_node_range = VersionRange.new(
-          from: Semantic::Version.new(from),
-          to: Semantic::Version.new(to)
-        )
-      end
-
-      def recommend_default_node_range
-        recommend_node(
-          from: Constants::SupportedVersions::Node::FROM,
-          to: Constants::SupportedVersions::Node::TO
-        )
-      end
-
-      def check_node_version
-        return unless @compatible_node_range
-
-        check_version(
-          Environment.node_version,
-          range: @compatible_node_range,
-          runtime: "Node"
-        )
-      end
-
-      def check_version(version, range:, runtime:, context: Context.new)
-        return if Environment.test? || Environment.run_as_subprocess?
-        return if range.nil?
-
-        version_without_pre_nor_build = Utilities.version_dropping_pre_and_build(version)
-        is_higher_than_bottom = version_without_pre_nor_build >= Utilities.version_dropping_pre_and_build(range.from)
-        is_lower_than_top = version_without_pre_nor_build < Utilities.version_dropping_pre_and_build(range.to)
-        return if is_higher_than_bottom && is_lower_than_top
-
-        context.warn("Your environment #{runtime} version, #{version},"\
-          " is outside of the range supported by the CLI,"\
-          " #{range.from}..<#{range.to},"\
-          " and might cause incompatibility issues.")
-      rescue StandardError => error
-        ExceptionReporter.report_error_silently(error)
-      end
-
-      def prerequisite_task(*tasks_without_args, **tasks_with_args)
-        @prerequisite_tasks ||= []
-        @prerequisite_tasks += tasks_without_args.map { |t| PrerequisiteTask.new(t) }
-        @prerequisite_tasks += tasks_with_args.map { |t, args| PrerequisiteTask.new(t, args) }
-      end
-
-      def run_prerequisites
-        (@prerequisite_tasks || []).each do |task|
-          task_registry[task.name]&.call(@ctx, *task.args)
-        end
-      end
-
-      def task_registry
-        @task_registry || ShopifyCLI::Tasks::Registry
-      end
-
-      class PrerequisiteTask
-        attr_reader :name, :args
-
-        def initialize(name, args = [])
-          @name = name
-          @args = args
-        end
-      end
-    end
-
-    def initialize(ctx = nil)
-      super()
-      @ctx = ctx || ShopifyCLI::Context.new
-      self.options = Options.new
-    end
-  end
-end

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

@@ -1,21 +0,0 @@
-require "shopify_cli"
-
-module ShopifyCLI
-  module Commands
-    Registry = CLI::Kit::CommandRegistry.new(
-      default: "help",
-      contextual_resolver: nil,
-    )
-    @core_commands = []
-
-    def self.register(const, cmd, path = nil, is_core = false)
-      autoload(const, path) if path
-      Registry.add(->() { const_get(const) }, cmd)
-      @core_commands.push(cmd) if is_core
-    end
-
-    def self.core_command?(cmd)
-      @core_commands.include?(cmd)
-    end
-  end
-end

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

@@ -1,101 +0,0 @@
-module ShopifyCLI
-  module Constants
-    module Paths
-      ROOT = File.expand_path("../..", __dir__)
-    end
-
-    module Files
-      SHOPIFY_CLI_YML = ".shopify-cli.yml"
-    end
-
-    module StoreKeys
-      LAST_MIGRATION_DATE = :last_migration_date
-      ANALYTICS_ENABLED = :analytics_enabled
-    end
-
-    module Bugsnag
-      API_KEY = "773b0c801eb40c20d8928be5b7c739bd"
-    end
-
-    module Config
-      module Sections
-        module Analytics
-          NAME = "analytics"
-          module Fields
-            ENABLED = "enabled"
-          end
-        end
-      end
-    end
-
-    module EnvironmentVariables
-      STACKTRACE = "SHOPIFY_CLI_STACKTRACE"
-      TTY = "SHOPIFY_CLI_TTY"
-      RUN_AS_SUBPROCESS = "SHOPIFY_CLI_RUN_AS_SUBPROCESS"
-      RUBY_BIN = "SHOPIFY_CLI_RUBY_BIN"
-      UNIFIED_DEPLOYMENT = "SHOPIFY_CLI_UNIFIED_DEPLOYMENT"
-      THEME_KIT_ACCESS_DOMAIN = "SHOPIFY_CLI_THEME_KIT_ACCESS_DOMAIN"
-
-      # When true the CLI points to a local instance of
-      # the partners dashboard and identity.
-      LOCAL_PARTNERS = "SHOPIFY_APP_CLI_LOCAL_PARTNERS"
-
-      # When true the CLI points to spin instances of services
-      SPIN = "SPIN"
-      SPIN_INSTANCE = "SPIN_INSTANCE"
-      SPIN_WORKSPACE = "SPIN_WORKSPACE"
-      SPIN_NAMESPACE = "SPIN_NAMESPACE"
-      SPIN_HOST = "SPIN_HOST"
-      SPIN_FQDN = "SPIN_FQDN"
-
-      # Deprecated, equivalent to using SPIN=1
-      SPIN_PARTNERS = "SHOPIFY_APP_CLI_SPIN_PARTNERS"
-
-      # Environments
-      TEST = "SHOPIFY_CLI_TEST"
-      ACCEPTANCE_TEST = "SHOPIFY_CLI_ACCEPTANCE_TEST"
-      DEVELOPMENT = "SHOPIFY_CLI_DEVELOPMENT"
-
-      # Authentication
-      AUTH_TOKEN = "SHOPIFY_CLI_AUTH_TOKEN"
-      ADMIN_AUTH_TOKEN = "SHOPIFY_CLI_ADMIN_AUTH_TOKEN"
-      STOREFRONT_RENDERER_AUTH_TOKEN =
-        "SHOPIFY_CLI_STOREFRONT_RENDERER_AUTH_TOKEN"
-
-      # Monorail
-      MONORAIL_REAL_EVENTS = "MONORAIL_REAL_EVENTS"
-
-      STORE = "SHOPIFY_SHOP"
-    end
-
-    module ThemeKitAccess
-      # override with SHOPIFY_CLI_THEME_KIT_ACCESS_DOMAIN
-      BASE_URL = "theme-kit-access.shopifyapps.com"
-    end
-
-    module SupportedVersions
-      module Ruby
-        FROM = "2.7.5"
-        TO = "3.2.10"
-      end
-
-      module Node
-        FROM = "14.5.0"
-        TO = "18.0.0"
-      end
-    end
-
-    module Identity
-      CLIENT_ID_DEV = "e5380e02-312a-7408-5718-e07017e9cf52"
-      CLIENT_ID = "fbdb2649-e327-4907-8f67-908d24cfd7e3"
-    end
-
-    module Links
-      NEW_ISSUE = "https://github.com/Shopify/cli/issues/new"
-    end
-
-    module Extension
-      DEFAULT_PORT = 39_351
-    end
-  end
-end