@shopify/cli-kit 3.45.0 → 3.46.0-pre.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@shopify/cli-kit",
-  "version": "3.45.0",
+  "version": "3.46.0-pre.0",
   "private": false,
   "description": "A set of utilities, interfaces, and models that are common across all the platform features",
   "keywords": [

package/assets/cli-ruby/lib/project_types/extension/commands/build.rb

@@ -1,51 +0,0 @@
-# frozen_string_literal: true
-require "shopify_cli"
-
-module Extension
-  class Command
-    class Build < ExtensionCommand
-      prerequisite_task ensure_project_type: :extension
-
-      YARN_BUILD_COMMAND = %w(build)
-      NPM_BUILD_COMMAND = %w(run-script build)
-
-      def call(_args, _command_name)
-        project = ExtensionProject.current(force_reload: true)
-        return run_new_flow(project) if supports_development_server?(project.specification_identifier)
-        run_legacy_flow
-      end
-
-      def self.help
-        ShopifyCLI::Context.new.message("build.help", ShopifyCLI::TOOL_NAME)
-      end
-
-      private
-
-      def run_new_flow(project)
-        Tasks::ExecuteCommands
-          .build(
-            context: @ctx,
-            config_file_path: specification_handler.server_config_path,
-            type: project.specification_identifier.downcase
-          )
-          .then { |output| @ctx.puts(output) }
-          .unwrap do |error|
-            raise ShopifyCLI::Abort, error.message unless error.nil?
-          end
-      end
-
-      def run_legacy_flow
-        system = ShopifyCLI::JsSystem.new(ctx: @ctx)
-
-        CLI::UI::Frame.open(@ctx.message("build.frame_title", system.package_manager)) do
-          success = system.call(yarn: YARN_BUILD_COMMAND, npm: NPM_BUILD_COMMAND)
-          @ctx.abort(@ctx.message("build.build_failure_message")) unless success
-        end
-      end
-
-      def supports_development_server?(type)
-        Models::DevelopmentServerRequirements.supported?(type)
-      end
-    end
-  end
-end

package/assets/cli-ruby/lib/project_types/extension/commands/check.rb

@@ -1,51 +0,0 @@
-# frozen_string_literal: true
-require "theme_check"
-
-module Extension
-  class Command
-    class Check < ExtensionCommand
-      recommend_default_ruby_range
-
-      class CheckOptions < ShopifyCLI::Options
-        def initialize(ctx, theme_check)
-          super()
-          @theme_check = theme_check
-          @ctx = ctx
-        end
-
-        def parse(_options_block, args)
-          # Check if .theme-check.yml exists, or if another -C has been passed on the command line
-          unless args.include?("-C") || @ctx.file_exist?(".theme-check.yml")
-            args += ["-C", ":theme_app_extension"]
-          end
-          @theme_check.parse(args)
-        end
-      end
-
-      def initialize(*)
-        super
-        if project.specification_identifier == "THEME_APP_EXTENSION"
-          @theme_check = ThemeCheck::Cli.new
-          self.options = CheckOptions.new(@ctx, @theme_check)
-        end
-      end
-
-      def call(*)
-        if project.specification_identifier == "THEME_APP_EXTENSION"
-          begin
-            @theme_check.run!
-          rescue ThemeCheck::Cli::Abort, ThemeCheck::ThemeCheckError => e
-            raise ShopifyCLI::Abort,
-              ShopifyCLI::Context.message("theme.check.error", e.full_message)
-          end
-        else
-          @ctx.abort(@ctx.message("check.unsupported", project.specification_identifier))
-        end
-      end
-
-      def self.help
-        ShopifyCLI::Context.message("check.help", ShopifyCLI::TOOL_NAME)
-      end
-    end
-  end
-end

package/assets/cli-ruby/lib/project_types/extension/commands/connect.rb

@@ -1,35 +0,0 @@
-# frozen_string_literal: true
-module Extension
-  class Command
-    class Connect < ExtensionCommand
-      prerequisite_task :ensure_authenticated
-
-      def call(args, _)
-        with_connect_form(args) do |form|
-          ExtensionProject.write_env_file(
-            context: @ctx,
-            api_key: form.app.api_key,
-            api_secret: form.app.secret,
-            registration_id: form.registration.id,
-            registration_uuid: form.registration.uuid,
-            title: form.registration.title
-          )
-          @ctx.done(@ctx.message("connect.connected", form.app.title, form.registration.title))
-        end
-      end
-
-      def self.help
-        ShopifyCLI::Context.new.message("connect.help", ShopifyCLI::TOOL_NAME, ShopifyCLI::TOOL_NAME)
-      end
-
-      private
-
-      def with_connect_form(args)
-        form = Forms::Connect.ask(@ctx, args, { type: specification_handler.identifier.downcase })
-        return @ctx.puts(self.class.help) if form.nil?
-
-        yield form
-      end
-    end
-  end
-end

package/assets/cli-ruby/lib/project_types/extension/commands/create.rb

@@ -1,100 +0,0 @@
-# frozen_string_literal: true
-
-module Extension
-  class Command
-    class Create < ShopifyCLI::Command::SubCommand
-      prerequisite_task :ensure_authenticated
-
-      recommend_default_ruby_range
-
-      options do |parser, flags|
-        parser.on("--name=NAME") { |name| flags[:name] = name }
-        parser.on("--template=TEMPLATE") { |template| flags[:template] = template }
-        parser.on("--type=TYPE") { |type| flags[:type] = type.upcase }
-        parser.on("--api-key=KEY") { |key| flags[:api_key] = key.downcase }
-        parser.on("--getting-started") { flags[:getting_started] = true }
-      end
-
-      def call(args, _)
-        with_create_form(args) do |form, message_for_extension|
-          if Dir.exist?(form.directory_name)
-            @ctx.abort(message_for_extension["create.errors.directory_exists", form.directory_name])
-          end
-
-          ShopifyCLI::Result.success(supports_development_server?(form.type.identifier))
-            .then { |supported| create_extension(supported, form) }
-            .then { notify_success(form, message_for_extension) }
-            .unwrap { |err| @ctx.puts(message_for_extension["create.try_again"]) unless err.nil? }
-        end
-      end
-
-      def self.help
-        @ctx.message("create.help", ShopifyCLI::TOOL_NAME)
-      end
-
-      private
-
-      def with_create_form(args)
-        form = Forms::Create.ask(@ctx, args, options.flags)
-        return @ctx.puts(self.class.help) if form.nil?
-
-        yield form, form.type.method(:message_for_extension)
-      end
-
-      def supports_development_server?(type)
-        Models::DevelopmentServerRequirements.supported?(type)
-      end
-
-      def create_extension(supported, form)
-        if supported
-          use_new_create_flow(form)
-        else
-          use_legacy_flow(form)
-        end
-        ShopifyCLI::Result.success(nil)
-      end
-
-      def use_new_create_flow(form)
-        Tasks::ExecuteCommands.create(
-          root_dir: form.directory_name,
-          template: form.template,
-          type: form.type.identifier.downcase,
-          context: @ctx,
-        )
-          .then { |output| @ctx.puts(output) }
-          .unwrap do |error|
-            raise ShopifyCLI::Abort, error.message unless error.nil?
-          end
-
-        @ctx.chdir(form.directory_name)
-        write_env_file(form)
-      rescue => error
-        @ctx.debug(error)
-        raise error
-      end
-
-      def use_legacy_flow(form)
-        if form.type.create(form.directory_name, @ctx, getting_started: options.flags[:getting_started])
-          write_env_file(form)
-        else
-          raise StandardError
-        end
-      end
-
-      def write_env_file(form)
-        ExtensionProject.write_cli_file(context: @ctx, type: form.type.identifier)
-        ExtensionProject.write_env_file(
-          context: @ctx,
-          title: form.name,
-          api_key: form.app.api_key,
-          api_secret: form.app.secret
-        )
-      end
-
-      def notify_success(form, msg)
-        @ctx.puts(msg["create.ready_to_start", form.directory_name, form.name])
-        @ctx.puts(msg["create.learn_more", form.type.name])
-      end
-    end
-  end
-end

package/assets/cli-ruby/lib/project_types/extension/commands/info.rb

@@ -1,86 +0,0 @@
-# frozen_string_literal: true
-require "shopify_cli"
-
-module Extension
-  class Command
-    class Info < ExtensionCommand
-      hidden_feature
-
-      def call(*)
-        @ctx.puts("Extension Title: #{project.title}")
-        @ctx.puts("Extension UUID: #{project.registration_uuid}")
-        @ctx.puts("Extension ID: #{project.registration_id}")
-        theme_app_extension_additional_info
-      end
-
-      def self.help
-        ShopifyCLI::Context.new.message("info.help", ShopifyCLI::TOOL_NAME)
-      end
-
-      private
-
-      OPENING_SCHEMA = "{%schema%}"
-      CLOSING_SCHEMA = "{%endschema%}"
-
-      def theme_app_extension_additional_info
-        if project.specification_identifier == "THEME_APP_EXTENSION" && (infos = block_infos)
-          title = to_handle(app.title)
-          uuid = project.registration_uuid
-          @ctx.puts("Block Infos \n")
-          index = 1
-          infos.each do |type, blocks_name|
-            @ctx.puts(" << #{type} >>\n")
-            blocks_name.each do |block_name|
-              @ctx.puts(" #{index}. shopify://apps/#{title}/blocks/#{block_name}/#{uuid} \n")
-              index += 1
-            end
-          end
-        end
-      end
-
-      def app
-        @app ||= Tasks::GetApp.call(context: @ctx, api_key: project.app.api_key)
-      end
-
-      def block_infos
-        block_infos = {}
-        Dir["blocks/*.liquid"].map do |filename|
-          block_name = File.basename(filename, ".liquid")
-          json_schema = block_info(filename)
-
-          next unless json_schema
-          block_type = json_schema["target"] == "section" ? "App Block" : "App Embed"
-          block_infos[block_type] ||= []
-          block_infos[block_type] << block_name
-        end
-        block_infos
-      end
-
-      def block_info(filename)
-        output = File.read(filename)
-        output = output.gsub(/\s+/, "")
-
-        if output
-          opening_index = output.index(OPENING_SCHEMA) + OPENING_SCHEMA.size
-          closing_index = output.index(CLOSING_SCHEMA) - 1
-
-          if (schema = output.slice(opening_index..closing_index))
-            json_schema = JSON.parse(schema)
-          end
-        end
-        json_schema
-      rescue JSON::ParserError
-        {}
-      end
-
-      def to_handle(s)
-        s = s.dup
-        s.downcase!
-        s.delete!("'\"()[]")
-        s.gsub!(/\W+/, "-")
-        s.gsub!(/\A-+|-+\z/, "")
-        -s
-      end
-    end
-  end
-end

package/assets/cli-ruby/lib/project_types/extension/commands/push.rb

@@ -1,112 +0,0 @@
-# frozen_string_literal: true
-require "shopify_cli"
-
-module Extension
-  class Command
-    class Push < ShopifyCLI::Command::SubCommand
-      prerequisite_task ensure_project_type: :extension
-
-      recommend_default_ruby_range
-
-      options do |parser, flags|
-        parser.on("--api-key=API_KEY") { |api_key| flags[:api_key] = api_key.gsub('"', "") }
-        parser.on("--api-secret=API_SECRET") { |api_secret| flags[:api_secret] = api_secret.gsub('"', "") }
-        parser.on("--extension-id=EXTENSION_ID") do |registration_id|
-          flags[:registration_id] = registration_id.gsub('"', "")
-        end
-      end
-
-      TIME_DISPLAY_FORMAT = "%B %d, %Y %H:%M:%S %Z"
-
-      def call(args, name)
-        project = Extension::Loaders::Project.load(
-          context: @ctx,
-          directory: Dir.pwd,
-          api_key: options.flags[:api_key],
-          api_secret: options.flags[:api_secret],
-          registration_id: options.flags[:registration_id]
-        )
-        # on ci, registration id must be present
-        registration_id = options.flags[:registration_id]
-        check_registration(registration_id: registration_id, context: @ctx)
-
-        specification_handler = Extension::Loaders::SpecificationHandler.load(project: project, context: @ctx)
-        register_if_necessary(project: project, args: args, name: name)
-
-        Command::Build.new(@ctx).call(args, name) unless specification_handler.specification.options[:skip_build]
-        CLI::UI::Frame.open(@ctx.message("push.frame_title")) do
-          updated_draft_version = update_draft(project: project, specification_handler: specification_handler)
-          show_message(updated_draft_version, project: project)
-        end
-      end
-
-      def register_if_necessary(project:, args:, name:)
-        if ShopifyCLI::Environment.interactive? && !project.registered?
-          Command::Register.new(@ctx).call(args, name)
-        end
-      end
-
-      def check_registration(registration_id:, context:)
-        if !ShopifyCLI::Environment.interactive? && (!registration_id || registration_id.empty?)
-          message = context.message("errors.missing_push_options_ci", "--registration-id")
-          message += context.message("errors.missing_push_options_ci_solution", ShopifyCLI::TOOL_NAME)
-          raise ShopifyCLI::Abort,
-            message
-        end
-      end
-
-      def self.help
-        ShopifyCLI::Context.new.message("push.help", ShopifyCLI::TOOL_NAME)
-      end
-
-      private
-
-      def show_message(draft, project:)
-        if draft.validation_errors.empty?
-          output_success_messages(draft,
-            project: project)
-        else
-          output_validation_errors(draft)
-        end
-      end
-
-      def output_success_messages(draft, project:)
-        @ctx.puts(@ctx.message("push.success_confirmation", project.title, format_time(draft.last_user_interaction_at)))
-        @ctx.puts(@ctx.message("push.success_info", draft.location))
-      end
-
-      def output_validation_errors(draft)
-        @ctx.puts(@ctx.message("push.pushed_with_errors", format_time(draft.last_user_interaction_at)))
-
-        draft.validation_errors.each do |error|
-          @ctx.puts(format("{{x}} %s: %s", error.field.last, error.message))
-        end
-
-        @ctx.puts(@ctx.message("push.push_with_errors_info"))
-      end
-
-      def format_time(time)
-        time.utc.strftime(TIME_DISPLAY_FORMAT)
-      end
-
-      def with_waiting_text
-        @ctx.puts(@ctx.message("push.waiting_text"))
-        yield
-      end
-
-      def update_draft(project:, specification_handler:)
-        with_waiting_text do
-          Tasks::UpdateDraft.call(
-            context: @ctx,
-            api_key: project.app.api_key,
-            registration_id: project.registration_id,
-            config: specification_handler.config(@ctx),
-            extension_context: specification_handler.extension_context(@ctx)
-          )
-        end
-      rescue Extension::Errors::ExtensionError => e
-        @ctx.abort(e)
-      end
-    end
-  end
-end

package/assets/cli-ruby/lib/project_types/extension/commands/register.rb

@@ -1,67 +0,0 @@
-# frozen_string_literal: true
-
-module Extension
-  class Command
-    class Register < ExtensionCommand
-      prerequisite_task ensure_project_type: :extension
-
-      def call(_args, _command_name)
-        CLI::UI::Frame.open(@ctx.message("register.frame_title")) do
-          @ctx.abort(@ctx.message("register.already_registered")) if project.registered?
-
-          should_continue = confirm_registration
-          registration = should_continue ? register_extension : abort_not_registered
-
-          update_project_files(registration)
-
-          @ctx.puts(@ctx.message("register.success", project.title))
-          @ctx.puts(@ctx.message("register.success_info"))
-        end
-      end
-
-      def self.help
-        ShopifyCLI::Context.new.message("register.help", ShopifyCLI::TOOL_NAME)
-      end
-
-      private
-
-      def confirm_registration
-        @ctx.puts(@ctx.message("register.confirm_info", specification_handler.name))
-        CLI::UI::Prompt.confirm(@ctx.message("register.confirm_question"))
-      end
-
-      def register_extension
-        @ctx.puts(@ctx.message("register.waiting_text"))
-
-        Tasks::CreateExtension.call(
-          context: @ctx,
-          api_key: app.api_key,
-          type: specification_handler.graphql_identifier,
-          title: project.title,
-          config: {},
-          extension_context: specification_handler.extension_context(@ctx)
-        )
-      end
-
-      def update_project_files(registration)
-        ExtensionProject.write_env_file(
-          context: @ctx,
-          api_key: app.api_key,
-          api_secret: app.secret,
-          registration_id: registration.id,
-          registration_uuid: registration.uuid,
-          title: project.title
-        )
-      end
-
-      def app
-        @app ||= project.app
-      end
-
-      def abort_not_registered
-        @ctx.puts(@ctx.message("register.confirm_abort"))
-        raise ShopifyCLI::AbortSilent
-      end
-    end
-  end
-end

package/assets/cli-ruby/lib/project_types/extension/commands/tunnel.rb

@@ -1,73 +0,0 @@
-# frozen_string_literal: true
-require "shopify_cli"
-
-module Extension
-  class Command
-    class Tunnel < ExtensionCommand
-      prerequisite_task ensure_project_type: :extension
-
-      options do |parser, flags|
-        parser.on("--port=PORT") { |port| flags[:port] = port }
-      end
-
-      AUTH_SUBCOMMAND = "auth"
-      START_SUBCOMMAND = "start"
-      STOP_SUBCOMMAND = "stop"
-      STATUS_SUBCOMMAND = "status"
-      DEFAULT_PORT = 39351
-
-      def call(args, _name)
-        subcommand = args.shift
-
-        case subcommand
-        when AUTH_SUBCOMMAND then authorize(args)
-        when START_SUBCOMMAND then ShopifyCLI::Tunnel.start(@ctx, port: port)
-        when STOP_SUBCOMMAND then ShopifyCLI::Tunnel.stop(@ctx)
-        when STATUS_SUBCOMMAND then status
-        else @ctx.puts(self.class.help)
-        end
-      end
-
-      def self.help
-        ShopifyCLI::Context.message("tunnel.help", ShopifyCLI::TOOL_NAME)
-      end
-
-      def self.extended_help
-        ShopifyCLI::Context.message("tunnel.extended_help", ShopifyCLI::TOOL_NAME, DEFAULT_PORT)
-      end
-
-      private
-
-      def status
-        tunnel_urls = ShopifyCLI::Tunnel.urls
-        tunnel_url = tunnel_urls.find { |url| url.start_with?("https://") }
-        tunnel_url = tunnel_urls.first if tunnel_url.nil?
-
-        if tunnel_url.nil?
-          @ctx.puts(@ctx.message("tunnel.no_tunnel_running"))
-        else
-          @ctx.puts(@ctx.message("tunnel.tunnel_running_at", tunnel_url))
-        end
-      end
-
-      def port
-        return DEFAULT_PORT unless options.flags.key?(:port)
-
-        port = options.flags[:port].to_i
-        @ctx.abort(@ctx.message("tunnel.invalid_port", options.flags[:port])) unless port > 0
-        port
-      end
-
-      def authorize(args)
-        token = args.shift
-
-        if token.nil?
-          @ctx.puts(@ctx.message("tunnel.missing_token"))
-          @ctx.puts("#{self.class.help}\n#{self.class.extended_help}")
-        else
-          ShopifyCLI::Tunnel.auth(@ctx, token)
-        end
-      end
-    end
-  end
-end

package/assets/cli-ruby/lib/project_types/extension/forms/connect.rb

@@ -1,42 +0,0 @@
-# frozen_string_literal: true
-
-module Extension
-  module Forms
-    class Connect < ShopifyCLI::Form
-      attr_reader :registration, :app
-
-      flag_arguments :type
-
-      class ExtensionProjectDetails
-        include SmartProperties
-
-        property :registration, accepts: Models::Registration
-        property :app, accepts: Models::App
-
-        def complete?
-          !!(registration && app)
-        end
-      end
-
-      def ask
-        ShopifyCLI::Result.wrap(ExtensionProjectDetails.new)
-          .then(&Questions::AskRegistration.new(ctx: ctx, type: type))
-          .unwrap { |e| raise e }
-          .tap do |project_details|
-            ctx.abort(ctx.message("connect.incomplete_configuration")) unless project_details.complete?
-
-            self.registration = project_details.registration
-            self.app = project_details.app
-          end
-      end
-
-      def directory_name
-        name.strip.gsub(/( )/, "_").downcase
-      end
-
-      private
-
-      attr_writer :registration, :app
-    end
-  end
-end

package/assets/cli-ruby/lib/project_types/extension/forms/create.rb

@@ -1,49 +0,0 @@
-# frozen_string_literal: true
-
-module Extension
-  module Forms
-    class Create < ShopifyCLI::Form
-      flag_arguments :name, :type, :api_key, :template
-
-      attr_reader :app
-
-      class ExtensionProjectDetails
-        include SmartProperties
-
-        property :app, accepts: Models::App
-        property :name, accepts: String
-        property :type, accepts: Models::SpecificationHandlers::Default
-        property :template, accepts: String
-
-        def complete?
-          !!(app && name && type)
-        end
-      end
-
-      def ask
-        ShopifyCLI::Result.wrap(ExtensionProjectDetails.new)
-          .then(&Questions::AskApp.new(ctx: ctx, api_key: api_key))
-          .then(&Questions::AskType.new(ctx: ctx, type: type))
-          .then(&Questions::AskTemplate.new(ctx: ctx, template: template))
-          .then(&Questions::AskName.new(ctx: ctx, name: name))
-          .unwrap { |e| raise e }
-          .tap do |project_details|
-            ctx.abort(ctx.message("create.incomplete_configuration")) unless project_details.complete?
-
-            self.app = project_details.app
-            self.type = project_details.type
-            self.template = project_details.template
-            self.name = project_details.name
-          end
-      end
-
-      def directory_name
-        name.strip.gsub(/( )/, "_").downcase
-      end
-
-      private
-
-      attr_writer :app
-    end
-  end
-end