@shopify/cli-kit 3.38.0 → 3.40.0

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

@@ -0,0 +1,156 @@
+# frozen_string_literal: true
+
+require "pathname"
+require "json"
+require "yaml"
+
+module Extension
+  class PackageResolutionFailed < RuntimeError; end
+
+  class Project < ShopifyCLI::ProjectType
+    hidden_feature
+
+    require Project.project_filepath("messages/messages")
+    require Project.project_filepath("messages/message_loading")
+    require Project.project_filepath("extension_project_keys")
+    register_messages(Extension::Messages::MessageLoading.load)
+  end
+
+  class Command < ShopifyCLI::Command::ProjectCommand
+    autoload :ExtensionCommand, Project.project_filepath("commands/extension_command")
+
+    subcommand :Create, "create", Project.project_filepath("commands/create")
+    subcommand :Register, "register", Project.project_filepath("commands/register")
+    subcommand :Info, "info", Project.project_filepath("commands/info")
+    subcommand :Connect, "connect", Project.project_filepath("commands/connect")
+    subcommand :Build, "build", Project.project_filepath("commands/build")
+    subcommand :Serve, "serve", Project.project_filepath("commands/serve")
+    subcommand :Push, "push", Project.project_filepath("commands/push")
+    subcommand :Tunnel, "tunnel", Project.project_filepath("commands/tunnel")
+    subcommand :Check, "check", Project.project_filepath("commands/check")
+  end
+  ShopifyCLI::Commands.register("Extension::Command", "extension")
+
+  module Tasks
+    autoload :UserErrors, Project.project_filepath("tasks/user_errors")
+    autoload :GetApps, Project.project_filepath("tasks/get_apps")
+    autoload :GetApp, Project.project_filepath("tasks/get_app")
+    autoload :CreateExtension, Project.project_filepath("tasks/create_extension")
+    autoload :UpdateDraft, Project.project_filepath("tasks/update_draft")
+    autoload :FetchSpecifications, Project.project_filepath("tasks/fetch_specifications")
+    autoload :ConfigureFeatures, Project.project_filepath("tasks/configure_features")
+    autoload :ConfigureOptions, Project.project_filepath("tasks/configure_options")
+    autoload :ChooseNextAvailablePort, Project.project_filepath("tasks/choose_next_available_port")
+    autoload :FindNpmPackages, Project.project_filepath("tasks/find_npm_packages")
+    autoload :GetExtensions, Project.project_filepath("tasks/get_extensions")
+    autoload :GetProduct, Project.project_filepath("tasks/get_product")
+    autoload :MergeServerConfig, Project.project_filepath("tasks/merge_server_config")
+    autoload :FindPackageFromJson, Project.project_filepath("tasks/find_package_from_json.rb")
+    autoload :EnsureResourceUrl, Project.project_filepath("tasks/ensure_resource_url.rb")
+    autoload :ConvertServerConfig, Project.project_filepath("tasks/convert_server_config")
+
+    module Converters
+      autoload :RegistrationConverter, Project.project_filepath("tasks/converters/registration_converter")
+      autoload :VersionConverter, Project.project_filepath("tasks/converters/version_converter")
+      autoload :ValidationErrorConverter, Project.project_filepath("tasks/converters/validation_error_converter")
+      autoload :AppConverter, Project.project_filepath("tasks/converters/app_converter")
+      autoload :ProductConverter, Project.project_filepath("tasks/converters/product_converter")
+      autoload :ExecuteCommands, Project.project_filepath("cli/execute_commands")
+    end
+
+    module ExecuteCommands
+      autoload :Base, Project.project_filepath("tasks/execute_commands/base")
+      autoload :Build, Project.project_filepath("tasks/execute_commands/build")
+      autoload :Create, Project.project_filepath("tasks/execute_commands/create")
+      autoload :Serve, Project.project_filepath("tasks/execute_commands/serve")
+      autoload :OutdatedExtensionDetection,
+        Project.project_filepath("tasks/execute_commands/outdated_extension_detection")
+
+      class << self
+        def build(*args)
+          Build.new(*args).call
+        end
+
+        def create(*args)
+          Create.new(*args).call
+        end
+
+        def serve(*args)
+          Serve.new(*args).call
+        end
+      end
+    end
+  end
+
+  module Forms
+    module Questions
+      autoload :AskApp, Project.project_filepath("forms/questions/ask_app")
+      autoload :AskName, Project.project_filepath("forms/questions/ask_name")
+      autoload :AskTemplate, Project.project_filepath("forms/questions/ask_template")
+      autoload :AskType, Project.project_filepath("forms/questions/ask_type")
+      autoload :AskRegistration, Project.project_filepath("forms/questions/ask_registration")
+    end
+
+    autoload :Create, Project.project_filepath("forms/create")
+    autoload :Register, Project.project_filepath("forms/register")
+    autoload :Connect, Project.project_filepath("forms/connect")
+  end
+
+  module Features
+    module Runtimes
+      autoload :Admin, Project.project_filepath("features/runtimes/admin")
+      autoload :Base, Project.project_filepath("features/runtimes/base")
+      autoload :CheckoutPostPurchase, Project.project_filepath("features/runtimes/checkout_post_purchase")
+      autoload :CheckoutUiExtension, Project.project_filepath("features/runtimes/checkout_ui_extension")
+    end
+    autoload :ArgoServe, Project.project_filepath("features/argo_serve")
+    autoload :ArgoServeOptions, Project.project_filepath("features/argo_serve_options")
+    autoload :ArgoSetup, Project.project_filepath("features/argo_setup")
+    autoload :ArgoSetupStep, Project.project_filepath("features/argo_setup_step")
+    autoload :ArgoSetupSteps, Project.project_filepath("features/argo_setup_steps")
+    autoload :ArgoDependencies, Project.project_filepath("features/argo_dependencies")
+    autoload :ArgoConfig, Project.project_filepath("features/argo_config")
+    autoload :ArgoRuntime, Project.project_filepath("features/argo_runtime")
+    autoload :Argo, Project.project_filepath("features/argo")
+  end
+
+  module Models
+    module SpecificationHandlers
+      autoload :Default, Project.project_filepath("models/specification_handlers/default")
+    end
+
+    module ServerConfig
+      autoload :Base, Project.project_filepath("models/server_config/base")
+      autoload :App, Project.project_filepath("models/server_config/app")
+      autoload :Capabilities, Project.project_filepath("models/server_config/capabilities")
+      autoload :Development, Project.project_filepath("models/server_config/development")
+      autoload :DevelopmentEntries, Project.project_filepath("models/server_config/development_entries")
+      autoload :DevelopmentRenderer, Project.project_filepath("models/server_config/development_renderer")
+      autoload :DevelopmentResource, Project.project_filepath("models/server_config/development_resource")
+      autoload :Extension, Project.project_filepath("models/server_config/extension")
+      autoload :Root, Project.project_filepath("models/server_config/root")
+      autoload :User, Project.project_filepath("models/server_config/user")
+    end
+
+    autoload :App, Project.project_filepath("models/app")
+    autoload :Registration, Project.project_filepath("models/registration")
+    autoload :Version, Project.project_filepath("models/version")
+    autoload :ValidationError, Project.project_filepath("models/validation_error")
+    autoload :Specification, Project.project_filepath("models/specification")
+    autoload :Specifications, Project.project_filepath("models/specifications")
+    autoload :LazySpecificationHandler, Project.project_filepath("models/lazy_specification_handler")
+    autoload :NpmPackage, Project.project_filepath("models/npm_package")
+    autoload :Product, Project.project_filepath("models/product")
+    autoload :DevelopmentServer, Project.project_filepath("models/development_server")
+    autoload :DevelopmentServerRequirements, Project.project_filepath("models/development_server_requirements")
+  end
+
+  autoload :ExtensionProjectKeys, Project.project_filepath("extension_project_keys")
+  autoload :ExtensionProject, Project.project_filepath("extension_project")
+  autoload :Errors, Project.project_filepath("errors")
+
+  module Loaders
+    autoload :Project, Extension::Project.project_filepath("loaders/project")
+    autoload :SpecificationHandler, Extension::Project.project_filepath("loaders/specification_handler")
+  end
+end

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

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

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

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

@@ -0,0 +1,100 @@
+# 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/extension_command.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+require "shopify_cli"
+
+module Extension
+  class Command
+    class ExtensionCommand < ShopifyCLI::Command::SubCommand
+      def project
+        @project ||= ExtensionProject.current
+      end
+
+      def specification_handler
+        @specification_handler ||= begin
+          identifier = project.specification_identifier
+          Models::LazySpecificationHandler.new(identifier) do
+            specifications = Models::Specifications.new(
+              fetch_specifications: Tasks::FetchSpecifications.new(api_key: project.app.api_key, context: @ctx)
+            )
+
+            unless specifications.valid?(identifier)
+              @ctx.abort(@ctx.message("errors.unknown_type", project.specification_identifier))
+            end
+
+            specifications[identifier]
+          end
+        end
+      end
+    end
+  end
+end

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

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

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