@shopify/cli-kit 3.38.0 → 3.40.0

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

@@ -0,0 +1,148 @@
+require "date"
+require "shopify_cli/sed"
+require "octokit"
+
+module ShopifyCLI
+  class Changelog
+    CHANGELOG_FILE = File.join(ShopifyCLI::ROOT, "CHANGELOG.md")
+    CHANGE_CATEGORIES = %w(Added Changed Deprecated Removed Fixed Security)
+
+    def initialize
+      load(File.read(CHANGELOG_FILE))
+    end
+
+    def update_version!(new_version)
+      changes[new_version] = changes["Unreleased"]
+      changes[new_version][:date] = Date.today.iso8601
+      changes["Unreleased"] = { changes: [], date: nil }
+      save!
+    end
+
+    def update!
+      pr = pr_for_current_branch
+      category = CLI::UI::Prompt.ask("What type of change?", options: CHANGE_CATEGORIES)
+      add_change(category, { pr_id: pr.number, desc: pr.title })
+      save!
+    end
+
+    def release_notes(version)
+      changes[version][:changes].map do |change_category, changes|
+        <<~CHANGES
+          ### #{change_category}
+          #{changes.map { |change| entry(**change) }.join("\n")}
+        CHANGES
+      end.join("\n")
+    end
+
+    def add_change(category, change)
+      changes["Unreleased"][:changes][category] << change
+    end
+
+    def entry(pr_id:, desc:)
+      "* [##{pr_id}](https://github.com/Shopify/shopify-cli/pull/#{pr_id}): #{desc}"
+    end
+
+    def full_contents
+      sorted_changes = changes.each_key.sort_by do |change|
+        if change == "Unreleased"
+          [Float::INFINITY] * 3 # end of the list
+        else
+          major, minor, patch = change.split(".").map(&:to_i)
+          [major, minor, patch]
+        end
+      end.reverse
+      [
+        heading,
+        *sorted_changes.each.map { |version| release_notes_with_header(version) }.join,
+        remainder,
+      ].map { |section| section.chomp << "\n" }.join
+    end
+
+    def save!
+      File.write(CHANGELOG_FILE, full_contents)
+    end
+
+    private
+
+    attr_reader :heading, :remainder
+
+    def release_notes_with_header(version)
+      header_line =
+        if version == "Unreleased"
+          "[Unreleased]"
+        else
+          date = changes[version][:date]
+          "Version #{version}#{" - #{date}" if date}"
+        end
+
+      [
+        "## #{header_line}",
+        release_notes(version),
+      ].reject(&:empty?).map { |section| section.chomp << "\n\n" }.join
+    end
+
+    def changes
+      @changes ||= Hash.new do |h, k|
+        h[k] = {
+          date: nil,
+          changes: Hash.new do |h2, k2|
+            h2[k2] = []
+          end,
+        }
+      end
+    end
+
+    def load(log)
+      state = :initial
+      change_category = nil
+      current_version = nil
+      @heading = ""
+      @remainder = ""
+      log.each_line do |line|
+        case state
+        when :initial
+          if line.chomp == "\#\# [Unreleased]"
+            state = :unreleased
+            current_version = "Unreleased"
+            # Ensure Unreleased changeset exists even if no changes have happened yet
+            changes["Unreleased"]
+          else
+            @heading << line
+          end
+        when :unreleased, :prior_versions
+          if /\A\#\#\# (?<category>\w+)/ =~ line
+            change_category = category
+          elsif %r{\A\* \[\#(?<id>\d+)\]\(https://github.com/Shopify/shopify-cli/pull/\k<id>\): (?<desc>.+)\n} =~ line
+            changes[current_version][:changes][change_category] << { pr_id: id, desc: desc }
+          elsif /\A\#\# Version (?<version>\d+\.\d+\.\d+)( - (?<date>\d{4}-\d{2}-\d{2}))?/ =~ line
+            current_version = version
+            state = :prior_versions
+            major, minor, _patch = current_version.split(".")
+            if major.to_i <= 2 && minor.to_i < 7
+              # Changelog starts to become irregular in 2.6.x
+              state = :finished
+            end
+            changes[current_version][:date] = date unless state == :finished
+          elsif !line.match?(/\s*\n/)
+            raise "Unrecognized line: #{line.inspect}"
+          end
+        end
+        @remainder << line if state == :finished
+      end
+    end
+
+    def pr_for_current_branch
+      current_branch = %x(git branch --show-current).chomp
+      search_term = "repo:Shopify/shopify-cli is:pr is:open head:#{current_branch}"
+      results = Octokit::Client.new.search_issues(search_term)
+      case results.total_count
+      when 0
+        raise "PR not opened yet!"
+      when (2..)
+        raise "Multiple open PRs, not sure which one to use for changelog!"
+      end
+
+      results.items.first
+    end
+  end
+end

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

@@ -0,0 +1,26 @@
+module ShopifyCLI
+  class Command
+    class AppSubCommand < SubCommand
+      def detect_app(directory: Dir.pwd)
+        AppTypeDetector.detect(project_directory: directory)
+      rescue ShopifyCLI::AppTypeDetector::TypeNotFoundError
+        raise ShopifyCLI::Abort, @ctx.message("core.app.error.type_not_found", directory)
+      rescue ShopifyCLI::AppTypeDetector::MissingShopifyCLIYamlError
+        raise ShopifyCLI::Abort, @ctx.message("core.app.error.missing_shopify_cli_yml", directory)
+      rescue ShopifyCLI::AppTypeDetector::InvalidTypeError => error
+        raise ShopifyCLI::Abort, @ctx.message("core.app.error.invalid_project_type", error.project_type)
+      end
+
+      class << self
+        def call_help(*)
+          output = help
+          if respond_to?(:extended_help)
+            output += "\n"
+            output += extended_help
+          end
+          @ctx.puts(output)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,31 @@
+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

@@ -0,0 +1,21 @@
+# 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 || [])
+          return call_help(parent_command, command_name) if cmd.options.help
+          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

@@ -0,0 +1,173 @@
+# 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 :AppSubCommand,  "shopify_cli/command/app_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)
+          return call_help(command_name) if cmd.options.help
+          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
+
+      def call_help(*cmds)
+        help = Commands::Help.new(@ctx)
+        help.call(cmds, nil)
+      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/command_options/command_serve_options.rb

@@ -0,0 +1,53 @@
+require "shopify_cli"
+
+module ShopifyCLI
+  module CommandOptions
+    module CommandServeOptions
+      def self.included(base)
+        base.extend(ClassMethods)
+        base.class_eval do
+          def port
+            return ShopifyCLI::Tunnel::PORT.to_s unless options.flags.key?(:port)
+            port = options.flags[:port].to_i
+            @ctx.abort(@ctx.message("core.app.serve.error.invalid_port", options.flags[:port])) unless port > 0
+            port
+          end
+
+          def host
+            host = options.flags[:host]
+            unless host.nil?
+              @ctx.abort(@ctx.message("core.app.serve.error.host_must_be_https")) if host.match(/^https/i).nil?
+            end
+            host
+          end
+
+          def no_update
+            options.flags[:no_update] || false
+          end
+        end
+      end
+
+      module ClassMethods
+        def parse_host_option
+          options do |parser, flags|
+            parser.on("--host=HOST") do |h|
+              flags[:host] = h.gsub('"', "")
+            end
+          end
+        end
+
+        def parse_port_option
+          options do |parser, flags|
+            parser.on("--port=PORT") { |port| flags[:port] = port }
+          end
+        end
+
+        def parse_no_update_option
+          options do |parser, flags|
+            parser.on("--no-update") { flags[:no_update] = true }
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,7 @@
+require "shopify_cli"
+
+module ShopifyCLI
+  module CommandOptions
+    autoload :CommandServeOptions, "shopify_cli/command_options/command_serve_options"
+  end
+end

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

@@ -0,0 +1,22 @@
+module ShopifyCLI
+  module Commands
+    class App
+      class Connect < ShopifyCLI::Command::AppSubCommand
+        def call(_args, _command_name, *)
+          app_type = detect_app(directory: Dir.pwd)
+          project = ShopifyCLI::Project.current
+
+          Services::App::ConnectService.call(
+            app_type: app_type,
+            project: project,
+            context: @ctx
+          )
+        end
+
+        def self.help
+          ShopifyCLI::Context.message("core.app.connect.help", ShopifyCLI::TOOL_NAME, ShopifyCLI::TOOL_NAME)
+        end
+      end
+    end
+  end
+end

package/assets/cli-ruby/lib/shopify_cli/commands/app/create/node.rb

@@ -0,0 +1,40 @@
+module ShopifyCLI
+  module Commands
+    class App
+      class Create
+        class Node < ShopifyCLI::Command::AppSubCommand
+          prerequisite_task :ensure_authenticated
+          prerequisite_task :ensure_git_dependency
+
+          recommend_default_node_range
+          recommend_default_ruby_range
+
+          options do |parser, flags|
+            parser.on("--name=NAME") { |t| flags[:name] = t }
+            parser.on("--organization-id=ID") { |id| flags[:organization_id] = id }
+            parser.on("--store-domain=MYSHOPIFYDOMAIN") { |url| flags[:store_domain] = url }
+            parser.on("--type=APPTYPE") { |type| flags[:type] = type }
+            parser.on("--verbose") { flags[:verbose] = true }
+          end
+
+          def call(*)
+            Services::App::Create::NodeService.call(
+              name: options.flags[:name],
+              organization_id: options.flags[:organization_id],
+              store_domain: options.flags[:store_domain],
+              type: options.flags[:type],
+              verbose: !options.flags[:verbose].nil?,
+              context: @ctx
+            )
+          end
+
+          class << self
+            def help
+              ShopifyCLI::Context.message("core.app.create.node.help", ShopifyCLI::TOOL_NAME, ShopifyCLI::TOOL_NAME)
+            end
+          end
+        end
+      end
+    end
+  end
+end

package/assets/cli-ruby/lib/shopify_cli/commands/app/create/php.rb

@@ -0,0 +1,37 @@
+module ShopifyCLI
+  module Commands
+    class App
+      class Create
+        class PHP < ShopifyCLI::Command::AppSubCommand
+          prerequisite_task :ensure_authenticated
+          prerequisite_task :ensure_git_dependency
+
+          options do |parser, flags|
+            parser.on("--name=NAME") { |name| flags[:name] = name }
+            parser.on("--organization-id=ID") { |organization_id| flags[:organization_id] = organization_id }
+            parser.on("--store-domain=MYSHOPIFYDOMAIN") { |url| flags[:store_domain] = url }
+            parser.on("--type=APPTYPE") { |type| flags[:type] = type }
+            parser.on("--verbose") { flags[:verbose] = true }
+          end
+
+          def call(*)
+            Services::App::Create::PHPService.call(
+              name: options.flags[:name],
+              organization_id: options.flags[:organization_id],
+              store_domain: options.flags[:store_domain],
+              type: options.flags[:type],
+              verbose: !options.flags[:verbose].nil?,
+              context: @ctx
+            )
+          end
+
+          class << self
+            def help
+              ShopifyCLI::Context.message("core.app.create.php.help", ShopifyCLI::TOOL_NAME, ShopifyCLI::TOOL_NAME)
+            end
+          end
+        end
+      end
+    end
+  end
+end

package/assets/cli-ruby/lib/shopify_cli/commands/app/create/rails.rb

@@ -0,0 +1,42 @@
+module ShopifyCLI
+  module Commands
+    class App
+      class Create
+        class Rails < ShopifyCLI::Command::AppSubCommand
+          prerequisite_task :ensure_authenticated
+          prerequisite_task :ensure_git_dependency
+
+          recommend_default_ruby_range
+          recommend_default_node_range
+
+          options do |parser, flags|
+            parser.on("--name=NAME") { |t| flags[:name] = t }
+            parser.on("--organization-id=ID") { |id| flags[:organization_id] = id }
+            parser.on("--store-domain=MYSHOPIFYDOMAIN") { |url| flags[:store_domain] = url }
+            parser.on("--type=APPTYPE") { |type| flags[:type] = type }
+            parser.on("--db=DB") { |db| flags[:db] = db }
+            parser.on("--rails-opts=RAILSOPTS") { |opts| flags[:rails_opts] = opts }
+          end
+
+          def call(*)
+            Services::App::Create::RailsService.call(
+              name: options.flags[:name],
+              organization_id: options.flags[:organization_id],
+              store_domain: options.flags[:store_domain],
+              type: options.flags[:type],
+              db: options.flags[:db],
+              rails_opts: options.flags[:rails_opts],
+              context: @ctx
+            )
+          end
+
+          class << self
+            def help
+              ShopifyCLI::Context.message("core.app.create.rails.help", ShopifyCLI::TOOL_NAME, ShopifyCLI::TOOL_NAME)
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,28 @@
+module ShopifyCLI
+  module Commands
+    class App
+      class Create < ShopifyCLI::Command
+        subcommand :Rails, "rails", "shopify_cli/commands/app/create/rails"
+        subcommand :PHP, "php", "shopify_cli/commands/app/create/php"
+        subcommand :Node, "node", "shopify_cli/commands/app/create/node"
+
+        def call(_args, _command_name)
+          @ctx.puts(self.class.help)
+        end
+
+        def self.help
+          ShopifyCLI::Context.message("core.app.create.help", ShopifyCLI::TOOL_NAME, ShopifyCLI::TOOL_NAME)
+        end
+
+        def self.call_help(*)
+          output = help
+          if respond_to?(:extended_help)
+            output += "\n"
+            output += extended_help
+          end
+          @ctx.puts(output)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,51 @@
+module ShopifyCLI
+  module Commands
+    class App
+      class Deploy < ShopifyCLI::Command::AppSubCommand
+        prerequisite_task :ensure_git_dependency
+
+        recommend_default_ruby_range
+
+        def call(args, _name)
+          platform = args.shift
+          case platform
+          when "heroku"
+            case detect_app
+            when :rails
+              Services::App::Deploy::Heroku::RailsService.call(
+                context: @ctx
+              )
+            when :php
+              Services::App::Deploy::Heroku::PHPService.call(
+                context: @ctx
+              )
+            when :node
+              Services::App::Deploy::Heroku::NodeService.call(
+                context: @ctx
+              )
+            end
+          when nil
+            raise ShopifyCLI::Abort, @ctx.message(
+              "core.app.deploy.error.missing_platform",
+              ShopifyCLI::TOOL_NAME
+            )
+          else
+            raise ShopifyCLI::Abort, @ctx.message(
+              "core.app.deploy.error.invalid_platform",
+              platform,
+              ShopifyCLI::TOOL_NAME
+            )
+          end
+        end
+
+        def self.help
+          ShopifyCLI::Context.message("core.app.deploy.help", ShopifyCLI::TOOL_NAME, ShopifyCLI::TOOL_NAME)
+        end
+
+        def self.extended_help
+          ShopifyCLI::Context.message("core.app.deploy.extended_help", ShopifyCLI::TOOL_NAME)
+        end
+      end
+    end
+  end
+end