@shopify/cli 3.69.4 → 3.70.0

package/dist/assets/cli-ruby/lib/shopify_cli/core/cli_version.rb

@@ -1,20 +0,0 @@
-module ShopifyCLI
-  module Core
-    ##
-    # ShopifyCLI::Core::CliVersion checks that the CLI in use is correct for the project.
-    #
-    class CliVersion
-      class << self
-        def using_3_0?
-          !!cli_3_0_toml_dir
-        end
-
-        private
-
-        def cli_3_0_toml_dir
-          Utilities.directory("shopify.app.toml", Dir.pwd)
-        end
-      end
-    end
-  end
-end

package/dist/assets/cli-ruby/lib/shopify_cli/core/entry_point.rb

@@ -1,64 +0,0 @@
-require "shopify_cli"
-
-module ShopifyCLI
-  module Core
-    module EntryPoint
-      class << self
-        def call(args, ctx = Context.new)
-          show_warnings(ctx, args.join(" "))
-
-          ProjectType.load_all
-
-          task_registry = ShopifyCLI::Tasks::Registry
-
-          command, command_name, args = ShopifyCLI::Resolver.call(args)
-          executor = ShopifyCLI::Core::Executor.new(ctx, task_registry, log_file: ShopifyCLI.log_file)
-          ShopifyCLI::Core::Monorail.log(command_name, args) do
-            executor.call(command, command_name, args)
-          end
-        end
-
-        def show_warnings(ctx, args)
-          # Only instruct the user to update the CLI, or warn them that they're
-          # using CLI2 not CLI3, if they're running CLI2 directly. Otherwise the
-          # warnings will be confusing and/or incorrect.
-          return if Environment.run_as_subprocess?
-
-          show_sunset_warning(ctx, args)
-
-          if ctx.development? && !ctx.testing?
-            ctx.warn(
-              ctx.message(
-                "core.warning.development_version",
-                File.join(ShopifyCLI::ROOT, "bin", ShopifyCLI::TOOL_NAME)
-              )
-            )
-            # because `!ctx.new_version.nil?` will change the config by calling ::Config.set
-            # it's important to keep the checks in this order so that we don't trigger it while testing
-            # since changing the config will throw errors
-          elsif !ctx.testing? && !ctx.new_version.nil?
-            ctx.warn(ctx.message("core.warning.new_version", ShopifyCLI::VERSION, ctx.new_version))
-          end
-
-          if ShopifyCLI::Core::CliVersion.using_3_0?
-            ctx.warn(ctx.message("core.warning.in_3_0_directory"))
-          end
-        end
-
-        def show_sunset_warning(ctx, args)
-          return if ctx.testing?
-
-          if args.start_with?("app create") || args.start_with?("app extension create")
-            ctx.warn(ctx.message("core.warning.sunset_create_app"))
-          elsif args.start_with?("app")
-            ctx.warn(ctx.message("core.warning.sunset_app"))
-          elsif args.start_with?("theme")
-            ctx.warn(ctx.message("core.warning.sunset_theme"))
-          else
-            ctx.warn(ctx.message("core.warning.sunset"))
-          end
-        end
-      end
-    end
-  end
-end

package/dist/assets/cli-ruby/lib/shopify_cli/core/executor.rb

@@ -1,23 +0,0 @@
-require "shopify_cli"
-
-module ShopifyCLI
-  module Core
-    class Executor < CLI::Kit::Executor
-      ruby2_keywords def initialize(ctx, task_registry, *args)
-        @ctx = ctx || ShopifyCli::Context.new
-        @task_registry = task_registry || ShopifyCli::Tasks::TaskRegistry.new
-        super(*args)
-      end
-
-      def call(command, command_name, args)
-        command.task_registry = @task_registry
-        command.ctx = @ctx
-        with_traps do
-          with_logging do |_id|
-            command.call(args, command_name)
-          end
-        end
-      end
-    end
-  end
-end

package/dist/assets/cli-ruby/lib/shopify_cli/core/finalize.rb

@@ -1,13 +0,0 @@
-module ShopifyCLI
-  module Core
-    # This class is just a dummy to make sure that we don't trigger warnings on the first time the updated code runs.
-    # The old code would try to call the Finalizer after it is done updating, which would then trigger an autoload of
-    # this class and fail.
-    module Finalize
-      class << self
-        def deliver!
-        end
-      end
-    end
-  end
-end

package/dist/assets/cli-ruby/lib/shopify_cli/core/monorail.rb

@@ -1,122 +0,0 @@
-require "json"
-require "net/http"
-require "time"
-require "rbconfig"
-
-module ShopifyCLI
-  module Core
-    module Monorail
-      ENDPOINT_URI = URI.parse("https://monorail-edge.shopifysvc.com/v1/produce")
-      INVOCATIONS_SCHEMA = "app_cli_command/5.0"
-
-      # Extra hash of data that will be sent in the payload
-      @metadata = {}
-
-      class << self
-        attr_accessor :metadata
-
-        def log(name, args, &block) # rubocop:disable Lint/UnusedMethodArgument
-          command, command_name = Commands::Registry.lookup_command(name)
-          full_command = self.full_command(command, args, resolved_command: [command_name])
-
-          start_time = now_in_milliseconds
-          err = nil
-
-          begin
-            yield
-          rescue Exception => e # rubocop:disable Lint/RescueException
-            err = e
-            raise
-          ensure
-            # If there's an error, we don't prompt from here and we let the exception
-            # reporter do that.
-            if report?(prompt: err.nil?)
-              send_event(start_time, full_command, args - full_command, err&.message)
-            end
-          end
-        end
-
-        def full_command(command, args, resolved_command:)
-          resolved_command = resolved_command.dup
-          if command
-            subcommand, subcommand_name = command.subcommand_registry.lookup_command(args.first)
-            resolved_command << subcommand_name if subcommand
-            if subcommand&.subcommand_registry
-              resolved_command = full_command(subcommand, args.drop(1), resolved_command: resolved_command)
-            end
-          end
-          resolved_command
-        end
-
-        private
-
-        def now_in_milliseconds
-          (Time.now.utc.to_f * 1000).to_i
-        end
-
-        def report?(prompt:)
-          return true if Environment.send_monorail_events?
-          ReportingConfigurationController.check_or_prompt_report_automatically(source: :usage, prompt: prompt)
-        end
-
-        def send_event(start_time, commands, args, err = nil)
-          end_time = now_in_milliseconds
-          headers = {
-            'Content-Type': "application/json; charset=utf-8",
-            'X-Monorail-Edge-Event-Created-At-Ms': start_time.to_s,
-            'X-Monorail-Edge-Event-Sent-At-Ms': end_time.to_s,
-          }
-          begin
-            Net::HTTP.start(
-              ENDPOINT_URI.host,
-              ENDPOINT_URI.port,
-              # timeouts for opening a connection, reading, writing (in seconds)
-              open_timeout: 0.2, read_timeout: 0.2, write_timeout: 0.2,
-              use_ssl: ENDPOINT_URI.scheme == "https"
-            ) do |http|
-              payload = build_payload(start_time, end_time, commands, args, err)
-              post = Net::HTTP::Post.new(ENDPOINT_URI.request_uri, headers)
-              post.body = JSON.dump(payload)
-              http.request(post)
-            end
-          rescue
-            # silently fail on errors, fire-and-forget approach
-          end
-        end
-
-        def build_payload(start_time, end_time, commands, args, err = nil)
-          {
-            schema_id: INVOCATIONS_SCHEMA,
-            payload: {
-              project_type: project_type_from_dir_or_cmd(commands[0]).to_s,
-              command: commands.join(" "),
-              args: args.join(" "),
-              time_start: start_time,
-              time_end: end_time,
-              total_time: end_time - start_time,
-              success: err.nil?,
-              error_message: err,
-              uname: RbConfig::CONFIG["host"],
-              cli_version: ShopifyCLI::VERSION,
-              ruby_version: RUBY_VERSION,
-              is_employee: ShopifyCLI::Shopifolk.acting_as_shopify_organization?,
-            }.tap do |payload|
-              payload[:api_key] = metadata.delete(:api_key)
-              payload[:partner_id] = metadata.delete(:organization_id) || ShopifyCLI::DB.get(:organization_id)
-              if Project.has_current?
-                project = Project.current(force_reload: true)
-                payload[:api_key] = project.env&.api_key
-                payload[:partner_id] = project.config["organization_id"]
-              end
-              payload[:metadata] = JSON.dump(metadata) unless metadata.empty?
-            end,
-          }
-        end
-
-        def project_type_from_dir_or_cmd(command)
-          Project.current_project_type || (command unless ShopifyCLI::Commands.core_command?(command)) || nil
-        end
-      end
-    end
-  end
-end

package/dist/assets/cli-ruby/lib/shopify_cli/core.rb

@@ -1,8 +0,0 @@
-module ShopifyCLI
-  module Core
-    autoload :EntryPoint, "shopify_cli/core/entry_point"
-    autoload :Executor, "shopify_cli/core/executor"
-    autoload :Monorail, "shopify_cli/core/monorail"
-    autoload :CliVersion, "shopify_cli/core/cli_version"
-  end
-end

package/dist/assets/cli-ruby/lib/shopify_cli/db.rb

@@ -1,114 +0,0 @@
-require "pstore"
-require "forwardable"
-
-module ShopifyCLI
-  # Persists transient data like access tokens that may be cleared
-  # when user clears their session
-  #
-  # All of the instance methods documented here can be used as class methods. All class
-  # methods are forwarded to a new instance of the database, pointing at the default
-  # path.
-  class DB
-    extend SingleForwardable
-    def_delegators :new, :keys, :exists?, :set, :get, :del, :clear
-
-    attr_reader :db # :nodoc:
-
-    def initialize(path: File.join(ShopifyCLI.cache_dir, ".db.pstore")) # :nodoc:
-      @db = PStore.new(path)
-    end
-
-    # Get all keys that exist in the database.
-    #
-    # #### Returns
-    # - `keys`: an array of string or symbol keys that exist in the database
-    #
-    # #### Usage
-    #
-    #   ShopifyCLI::DB.keys
-    #
-    def keys
-      db.transaction(true) { db.roots }
-    end
-
-    # Check to see if a key exists in the database, the key will only exist if it
-    # has a value so if the key exists then there is also a value.
-    #
-    # #### Parameters
-    # - `key`: a string or a symbol representation of a key that is stored in the DB
-    #
-    # #### Returns
-    # - `exists`: a boolean value if the key exists in the database
-    #
-    # #### Usage
-    #
-    #   exists = ShopifyCLI::DB.exists?('shopify_exchange_token')
-    #
-    def exists?(key)
-      db.transaction(true) { db.root?(key) }
-    end
-
-    # Persist a value by key in the local storage
-    #
-    # #### Parameters
-    # - `**args`: a hash of keys and values to persist in the database
-    #
-    # #### Usage
-    #
-    #   ShopifyCLI::DB.set(shopify_exchange_token: 'token', metric_consent: true)
-    #
-    def set(**args)
-      db.transaction do
-        args.each do |key, val|
-          if val.nil?
-            db.delete(key)
-          else
-            db[key] = val
-          end
-        end
-      end
-    end
-
-    # Gets a value from the DB that is associated with the supplied key
-    #
-    # #### Parameters
-    # - `key`: a string or a symbol representation of a key that is stored in the DB
-    #
-    # #### Returns
-    # - `value`: will be the previously saved value or nil if the key does not exist
-    #   in the database.
-    #
-    # #### Usage
-    #
-    #   ShopifyCLI::DB.get(:shopify_exchange_token)
-    #
-    def get(key)
-      val = db.transaction(true) { db[key] }
-      val = yield if val.nil? && block_given?
-      val
-    end
-
-    # Deletes a value from the local storage
-    #
-    # #### Parameters
-    # - `*args`: an array of strings or symbols that are keys to be removed from the database
-    #
-    # #### Usage
-    #
-    #   ShopifyCLI::DB.del(:shopify_exchange_token)
-    #
-    def del(*args)
-      db.transaction { args.each { |key| db.delete(key) } }
-    end
-
-    # Drops all keys from the database.
-    #
-    # #### Usage
-    #
-    #   ShopifyCLI::DB.clear
-    #
-    def clear
-      del(*keys)
-    end
-  end
-end

package/dist/assets/cli-ruby/lib/shopify_cli/environment.rb

@@ -1,217 +0,0 @@
-require "semantic/semantic"
-
-module ShopifyCLI
-  # The environment module provides an interface to get information from
-  # the environment in which the CLI runs
-  module Environment
-    TRUTHY_ENV_VARIABLE_VALUES = ["1", "true", "TRUE", "yes", "YES"]
-    SPIN_OVERRIDE_ENV_NAMES = [
-      Constants::EnvironmentVariables::SPIN_WORKSPACE,
-      Constants::EnvironmentVariables::SPIN_NAMESPACE,
-      Constants::EnvironmentVariables::SPIN_HOST,
-    ]
-    # https://github.com/Shopify/themekit-access/blob/4c3c917d78443160dcf24376a8b5ac6b9bef0bcd/app/models/password_token.rb#L8
-    THEME_ACCESS_PASSWORD_PREFIX = "shptka_"
-
-    def self.ruby_version(context: Context.new, env_variables: ENV)
-      ruby_bin = env_variables[Constants::EnvironmentVariables::RUBY_BIN] || "ruby"
-      output, status = context.capture2e(ruby_bin, "--version")
-      raise ShopifyCLI::Abort, context.message("core.errors.missing_ruby") unless status.success?
-      version = output.match(/ruby (\d+\.\d+\.\d+)/)[1]
-      ::Semantic::Version.new(version)
-    end
-
-    def self.node_version(context: Context.new)
-      output, status = context.capture2e("node", "--version")
-      raise ShopifyCLI::Abort, context.message("core.errors.missing_node") unless status.success?
-      version = output.match(/v(\d+\.\d+\.\d+)/)[1]
-      ::Semantic::Version.new(version)
-    end
-
-    def self.npm_version(context: Context.new)
-      output, status = context.capture2e("npm", "--version")
-      raise ShopifyCLI::Abort, context.message("core.errors.missing_npm") unless status.success?
-      version = output.match(/(\d+\.\d+\.\d+)/)[1]
-      ::Semantic::Version.new(version)
-    end
-
-    def self.rails_version(context: Context.new)
-      output, status = context.capture2e("rails", "--version")
-      context.abort(context.message("core.app.create.rails.error.install_failure", "rails")) unless status.success?
-      version = output.match(/Rails (\d+\.\d+\.\d+)/)[1]
-      ::Semantic::Version.new(version)
-    end
-
-    def self.interactive=(interactive)
-      @interactive = interactive
-    end
-
-    def self.interactive?(env_variables: ENV)
-      if env_variables.key?(Constants::EnvironmentVariables::TTY)
-        env_variable_truthy?(
-          Constants::EnvironmentVariables::TTY,
-          env_variables: env_variables
-        )
-      else
-        @interactive ||= STDIN.tty?
-      end
-    end
-
-    def self.development?(env_variables: ENV)
-      env_variable_truthy?(
-        Constants::EnvironmentVariables::DEVELOPMENT,
-        env_variables: env_variables
-      )
-    end
-
-    def self.use_local_partners_instance?(env_variables: ENV)
-      env_variable_truthy?(
-        Constants::EnvironmentVariables::LOCAL_PARTNERS,
-        env_variables: env_variables
-      )
-    end
-
-    def self.print_stacktrace?(env_variables: ENV)
-      env_variable_truthy?(
-        Constants::EnvironmentVariables::STACKTRACE,
-        env_variables: env_variables
-      ) || development?(env_variables: env_variables)
-    end
-
-    def self.test?(env_variables: ENV)
-      env_variable_truthy?(
-        Constants::EnvironmentVariables::TEST,
-        env_variables: env_variables
-      )
-    end
-
-    def self.acceptance_test?(env_variables: ENV)
-      env_variable_truthy?(
-        Constants::EnvironmentVariables::ACCEPTANCE_TEST,
-        env_variables: env_variables
-      )
-    end
-
-    def self.print_backtrace?(env_variables: ENV)
-      env_variable_truthy?(
-        Constants::EnvironmentVariables::BACKTRACE,
-        env_variables: env_variables
-      )
-    end
-
-    def self.partners_domain(env_variables: ENV)
-      if use_local_partners_instance?(env_variables: env_variables)
-        "partners.myshopify.io"
-      elsif use_spin?(env_variables: env_variables)
-        "partners.#{spin_url(env_variables: env_variables)}"
-      else
-        "partners.shopify.com"
-      end
-    end
-
-    def self.spin_url_override(env_variables: ENV)
-      return env_variables[Constants::EnvironmentVariables::SPIN_FQDN] if env_variables.key?(
-        Constants::EnvironmentVariables::SPIN_FQDN
-      )
-
-      tokens = SPIN_OVERRIDE_ENV_NAMES.map do |name|
-        env_variables[name]
-      end
-
-      return if tokens.all?(&:nil?)
-
-      if tokens.any?(&:nil?)
-        raise "To manually target a spin instance, you must set #{SPIN_OVERRIDE_ENV_NAMES}"
-      else
-        tokens.join(".")
-      end
-    end
-
-    def self.use_spin?(env_variables: ENV)
-      env_variable_truthy?(
-        Constants::EnvironmentVariables::SPIN,
-        env_variables: env_variables
-      ) || env_variable_truthy?(
-        Constants::EnvironmentVariables::SPIN_PARTNERS,
-        env_variables: env_variables
-      )
-    end
-
-    def self.spin_url(env_variables: ENV)
-      override = spin_url_override(env_variables: env_variables)
-      return override unless override.nil?
-
-      spin_response = if env_variables.key?(
-        Constants::EnvironmentVariables::SPIN_INSTANCE
-      )
-        spin_show
-      else
-        spin_show(latest: true)
-      end
-
-      begin
-        instance = JSON.parse(spin_response)
-        raise "Missing key 'fqdn' from spin show. Actual response: #{instance}" unless instance.include?("fqdn")
-        instance["fqdn"]
-      rescue => e
-        raise "Failed to infer spin environment from spin show response #{spin_response}: #{e}"
-      end
-    end
-
-    def self.spin_show(latest: false)
-      latest ? %x(spin show --latest --json) : %x(spin show --json)
-    end
-
-    def self.send_monorail_events?(env_variables: ENV)
-      env_variable_truthy?(
-        Constants::EnvironmentVariables::MONORAIL_REAL_EVENTS,
-        env_variables: env_variables
-      ) && !run_as_subprocess?(env_variables: env_variables)
-    end
-
-    def self.auth_token(env_variables: ENV)
-      env_variables[Constants::EnvironmentVariables::AUTH_TOKEN]
-    end
-
-    def self.admin_auth_token(env_variables: ENV)
-      env_variables[Constants::EnvironmentVariables::ADMIN_AUTH_TOKEN]
-    end
-
-    def self.storefront_renderer_auth_token(env_variables: ENV)
-      env_variables[Constants::EnvironmentVariables::STOREFRONT_RENDERER_AUTH_TOKEN]
-    end
-
-    def self.store(env_variables: ENV)
-      env_variables[Constants::EnvironmentVariables::STORE]
-    end
-
-    def self.env_variable_truthy?(variable_name, env_variables: ENV)
-      TRUTHY_ENV_VARIABLE_VALUES.include?(env_variables[variable_name.to_s])
-    end
-
-    def self.run_as_subprocess?(env_variables: ENV)
-      env_variable_truthy?(
-        Constants::EnvironmentVariables::RUN_AS_SUBPROCESS,
-        env_variables: env_variables
-      )
-    end
-
-    def self.theme_access_password?
-      admin_auth_token&.start_with?(THEME_ACCESS_PASSWORD_PREFIX)
-    end
-
-    def self.unified_deployment?(env_variables: ENV)
-      env_variable_truthy?(
-        Constants::EnvironmentVariables::UNIFIED_DEPLOYMENT,
-        env_variables: env_variables
-      )
-    end
-
-    def self.theme_kit_access_domain(env_variables: ENV)
-      return env_variables[Constants::EnvironmentVariables::THEME_KIT_ACCESS_DOMAIN] if env_variables.key?(
-        Constants::EnvironmentVariables::THEME_KIT_ACCESS_DOMAIN
-      )
-      Constants::ThemeKitAccess::BASE_URL
-    end
-  end
-end

package/dist/assets/cli-ruby/lib/shopify_cli/exception_reporter.rb

@@ -1,80 +0,0 @@
-module ShopifyCLI
-  module ExceptionReporter
-    def self.report_error_silently(error)
-      return unless ReportingConfigurationController.reporting_enabled?
-      report_to_bugsnag(error: error)
-    end
-
-    def self.report(error, _logs = nil, _api_key = nil, custom_metadata = {})
-      context = ShopifyCLI::Context.new
-      unless ShopifyCLI::Environment.development?
-        context.puts(context.message("core.error_reporting.unhandled_error.message"))
-        context.puts(context.message("core.error_reporting.unhandled_error.issue_message",
-          ShopifyCLI::GitHub::IssueURLGenerator.error_url(error)))
-      end
-
-      # Stack trace hint
-      unless ShopifyCLI::Environment.print_stacktrace?
-        context.puts(context.message("core.error_reporting.unhandled_error.stacktrace_message",
-          "#{ShopifyCLI::Constants::EnvironmentVariables::STACKTRACE}=1"))
-      end
-
-      context.puts("\n")
-
-      return unless reportable_error?(error)
-
-      return unless report?(context: context)
-      report_to_bugsnag(error: error, custom_metadata: custom_metadata)
-    end
-
-    def self.report_to_bugsnag(error:, custom_metadata: {})
-      ENV["BUGSNAG_DISABLE_AUTOCONFIGURE"] = "1"
-      require "bugsnag"
-
-      Bugsnag.configure do |config|
-        config.logger.level = ::Logger::ERROR
-        config.api_key = ShopifyCLI::Constants::Bugsnag::API_KEY
-        config.app_type = "shopify"
-        config.project_root = File.expand_path("../../..", __FILE__)
-        config.app_version = ShopifyCLI::VERSION
-        config.auto_capture_sessions = false
-      end
-
-      metadata = { rubyPlatform: RUBY_PLATFORM }
-      metadata.merge!(custom_metadata)
-
-      Bugsnag.notify(error) do |event|
-        event.add_metadata(:device, metadata)
-      end
-    rescue
-      nil
-    end
-
-    def self.report?(context:)
-      return true if ReportingConfigurationController.reporting_prompted? &&
-        ReportingConfigurationController.check_or_prompt_report_automatically(source: :uncaught_error)
-
-      report_error = report_error?(context: context)
-
-      unless ReportingConfigurationController.reporting_prompted?
-        ReportingConfigurationController.check_or_prompt_report_automatically(source: :uncaught_error)
-      end
-      report_error
-    end
-
-    def self.report_error?(context:)
-      return false if Environment.development?
-      return false unless Environment.interactive?
-
-      CLI::UI::Prompt.ask(context.message("core.error_reporting.report_error.question")) do |handler|
-        handler.option(context.message("core.error_reporting.report_error.yes")) { |_| true }
-        handler.option(context.message("core.error_reporting.report_error.no")) { |_| false }
-      end
-    end
-
-    def self.reportable_error?(error)
-      is_abort = error.is_a?(ShopifyCLI::Abort) || error.is_a?(ShopifyCLI::AbortSilent)
-      !is_abort
-    end
-  end
-end