@shopify/cli-kit 3.39.0 → 3.40.0

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

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+require "shopify_cli"
+
+module Extension
+  module Tasks
+    module UserErrors
+      USER_ERRORS_FIELD = "userErrors"
+      MESSAGE_FIELD = "message"
+      USER_ERRORS_PARSE_ERROR = "Unable to parse errors from server."
+
+      def abort_if_user_errors(context, response)
+        return if response.nil?
+
+        user_errors = response.dig(USER_ERRORS_FIELD)
+        output_all_user_errors(context, user_errors)
+      end
+
+      private
+
+      def output_all_user_errors(context, user_errors)
+        return if user_errors.nil? || user_errors.empty?
+        last_user_error = user_errors.pop
+
+        user_errors.each { |user_error| puts_user_error(context, user_error) }
+        abort_user_error(context, last_user_error)
+      end
+
+      def puts_user_error(context, user_error)
+        output_user_error(context, user_error) { |message| context.puts("{{x}} #{message}") }
+      end
+
+      def abort_user_error(context, user_error)
+        output_user_error(context, user_error) { |message| context.abort(message) }
+      end
+
+      def output_user_error(context, user_error)
+        if user_error.key?(MESSAGE_FIELD)
+          yield(user_error[MESSAGE_FIELD])
+        else
+          context.abort(USER_ERRORS_PARSE_ERROR)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+module Node
+  class Project < ShopifyCLI::ProjectType
+    require Project.project_filepath("messages/messages")
+    register_messages(Node::Messages::MESSAGES)
+  end
+
+  # define/autoload project specific Forms
+  module Forms
+    autoload :Create, Project.project_filepath("forms/create")
+  end
+end

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

@@ -0,0 +1,45 @@
+require "uri"
+
+module Node
+  module Forms
+    class Create < ShopifyCLI::Form
+      attr_accessor :name
+      flag_arguments :name, :organization_id, :shop_domain, :type
+
+      def ask
+        self.name ||= CLI::UI::Prompt.ask(ctx.message("node.forms.create.app_name"))
+        self.name = format_name
+        self.type = ask_type
+        res = ShopifyCLI::Tasks::SelectOrgAndShop.call(ctx, organization_id: organization_id, shop_domain: shop_domain)
+        self.organization_id = res[:organization_id]
+        self.shop_domain = res[:shop_domain]
+      end
+
+      private
+
+      def format_name
+        formatted_name = name.downcase.split(" ").join("_")
+
+        if formatted_name.include?("shopify")
+          ctx.abort(ctx.message("node.forms.create.error.invalid_app_name"))
+        end
+        formatted_name
+      end
+
+      def ask_type
+        if type.nil?
+          return CLI::UI::Prompt.ask(ctx.message("node.forms.create.app_type.select")) do |handler|
+            handler.option(ctx.message("node.forms.create.app_type.select_public")) { "public" }
+            handler.option(ctx.message("node.forms.create.app_type.select_custom")) { "custom" }
+          end
+        end
+
+        unless ShopifyCLI::Tasks::CreateApiClient::VALID_APP_TYPES.include?(type)
+          ctx.abort(ctx.message("node.forms.create.error.invalid_app_type", type))
+        end
+        ctx.puts(ctx.message("node.forms.create.app_type.selected", type))
+        type
+      end
+    end
+  end
+end

package/assets/cli-ruby/lib/project_types/node/messages/messages.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Node
+  module Messages
+    MESSAGES = {
+      node: {
+        help: <<~HELP,
+          Suite of commands for developing Node.js apps. See {{command:%1$s app node <command> --help}} for usage of each command.
+            Usage: {{command:%1$s app node [ %2$s ]}}
+        HELP
+
+        error: {
+          generic: "Error",
+        },
+        forms: {
+          create: {
+            error: {
+              invalid_app_name: "App name cannot contain 'Shopify'",
+              invalid_app_type: "Invalid app type %s",
+            },
+            app_name: "App name",
+            app_type: {
+              select: "What type of app are you building?",
+              select_public: "Public: An app built for a wide merchant audience.",
+              select_custom: "Custom: An app custom built for a single client.",
+              selected: "App type {{green:%s}}",
+            },
+          },
+        },
+      },
+    }.freeze
+  end
+end

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

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+module PHP
+  class Project < ShopifyCLI::ProjectType
+    require Project.project_filepath("messages/messages")
+    register_messages(PHP::Messages::MESSAGES)
+  end
+
+  # define/autoload project specific Tasks
+  module Tasks
+  end
+
+  # define/autoload project specific Forms
+  module Forms
+    autoload :Create, Project.project_filepath("forms/create")
+  end
+end

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

@@ -0,0 +1,44 @@
+require "uri"
+
+module PHP
+  module Forms
+    class Create < ShopifyCLI::Form
+      flag_arguments :name, :organization_id, :shop_domain, :type
+
+      def ask
+        self.name ||= CLI::UI::Prompt.ask(ctx.message("php.forms.create.app_name"))
+        self.name = format_name
+        self.type = ask_type
+        res = ShopifyCLI::Tasks::SelectOrgAndShop.call(ctx, organization_id: organization_id, shop_domain: shop_domain)
+        self.organization_id = res[:organization_id]
+        self.shop_domain = res[:shop_domain]
+      end
+
+      private
+
+      def format_name
+        formatted_name = name.downcase.split(" ").join("_")
+
+        if formatted_name.include?("shopify")
+          ctx.abort(ctx.message("php.forms.create.error.invalid_app_name"))
+        end
+        formatted_name
+      end
+
+      def ask_type
+        if type.nil?
+          return CLI::UI::Prompt.ask(ctx.message("php.forms.create.app_type.select")) do |handler|
+            handler.option(ctx.message("php.forms.create.app_type.select_public")) { "public" }
+            handler.option(ctx.message("php.forms.create.app_type.select_custom")) { "custom" }
+          end
+        end
+
+        unless ShopifyCLI::Tasks::CreateApiClient::VALID_APP_TYPES.include?(type)
+          ctx.abort(ctx.message("php.forms.create.error.invalid_app_type", type))
+        end
+        ctx.puts(ctx.message("php.forms.create.app_type.selected", type))
+        type
+      end
+    end
+  end
+end

package/assets/cli-ruby/lib/project_types/php/messages/messages.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module PHP
+  module Messages
+    MESSAGES = {
+      php: {
+        help: <<~HELP,
+          Suite of commands for developing PHP apps with Laravel. See {{command:%1$s app php <command> --help}} for usage of each command.
+            Usage: {{command:%1$s app php [ %2$s ]}}
+        HELP
+        forms: {
+          create: {
+            error: {
+              invalid_app_name: "App name cannot contain 'Shopify'",
+              invalid_app_type: "Invalid app type %s",
+            },
+            app_name: "App name",
+            app_type: {
+              select: "What type of app are you building?",
+              select_public: "Public: An app built for a wide merchant audience.",
+              select_custom: "Custom: An app custom built for a single client.",
+              selected: "App type {{green:%s}}",
+            },
+          },
+        },
+      },
+    }.freeze
+  end
+end

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

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+module Rails
+  class Project < ShopifyCLI::ProjectType
+    require Project.project_filepath("messages/messages")
+    register_messages(Rails::Messages::MESSAGES)
+  end
+
+  # define/autoload project specific Forms
+  module Forms
+    autoload :Create, Project.project_filepath("forms/create")
+  end
+
+  autoload :Ruby, Project.project_filepath("ruby")
+  autoload :Gem, Project.project_filepath("gem")
+end

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

@@ -0,0 +1,75 @@
+require "uri"
+
+module Rails
+  module Forms
+    class Create < ShopifyCLI::Form
+      flag_arguments :name, :organization_id, :shop_domain, :type, :db
+      VALID_DB_TYPES = ["sqlite3",
+                        "mysql",
+                        "postgresql",
+                        "oracle",
+                        "frontbase",
+                        "ibm_db",
+                        "sqlserver",
+                        "jdbcmysql",
+                        "jdbcsqlite3",
+                        "jdbcpostgresql",
+                        "jdbc"]
+
+      def ask
+        self.name ||= CLI::UI::Prompt.ask(ctx.message("rails.forms.create.app_name"))
+        self.name = format_name
+        self.type = ask_type
+        res = ShopifyCLI::Tasks::SelectOrgAndShop.call(ctx, organization_id: organization_id, shop_domain: shop_domain)
+        self.organization_id = res[:organization_id]
+        self.shop_domain = res[:shop_domain]
+        self.db = ask_db
+      end
+
+      private
+
+      def format_name
+        formatted_name = name.downcase.split(" ").join("_")
+
+        if formatted_name.include?("shopify")
+          ctx.abort(ctx.message("rails.forms.create.error.invalid_app_name"))
+        end
+
+        formatted_name
+      end
+
+      def ask_type
+        if type.nil?
+          return CLI::UI::Prompt.ask(ctx.message("rails.forms.create.app_type.select")) do |handler|
+            handler.option(ctx.message("rails.forms.create.app_type.select_public")) { "public" }
+            handler.option(ctx.message("rails.forms.create.app_type.select_custom")) { "custom" }
+          end
+        end
+
+        unless ShopifyCLI::Tasks::CreateApiClient::VALID_APP_TYPES.include?(type)
+          ctx.abort(ctx.message("rails.forms.create.error.invalid_app_type", type))
+        end
+        ctx.puts(ctx.message("rails.forms.create.app_type.selected", type))
+        type
+      end
+
+      def ask_db
+        if db.nil?
+          return "sqlite3" unless CLI::UI::Prompt.confirm(ctx.message("rails.forms.create.db.want_select"),
+            default: false)
+          @db = CLI::UI::Prompt.ask(ctx.message("rails.forms.create.db.select")) do |handler|
+            VALID_DB_TYPES.each do |db_type|
+              handler.option(ctx.message("rails.forms.create.db.select_#{db_type}")) { db_type }
+            end
+          end
+        end
+
+        unless VALID_DB_TYPES.include?(db)
+          ctx.abort(ctx.message("rails.forms.create.error.invalid_db_type", db))
+        end
+        ctx.puts(ctx.message("rails.forms.create.db.selected", db))
+        db
+      end
+    end
+  end
+end

package/assets/cli-ruby/lib/project_types/rails/gem.rb

@@ -0,0 +1,110 @@
+# frozen_string_literal: true
+require "shopify_cli"
+
+module Rails
+  class Gem
+    include SmartProperties
+
+    property :ctx, accepts: ShopifyCLI::Context, required: true
+    property :name, converts: :to_s, required: true
+    property :version, converts: :to_s
+
+    class << self
+      def install(ctx, *args)
+        name = args.shift
+        version = args.shift
+        gem = new(ctx: ctx, name: name, version: version)
+        ctx.debug(ctx.message("rails.gem.installed_debug", name, gem.installed?))
+        gem.installed? ? true : gem.install!
+      end
+
+      def binary_path_for(ctx, binary)
+        path_to_binary = File.join(gem_home(ctx), "bin", binary)
+        File.exist?(path_to_binary) ? path_to_binary : binary
+      end
+
+      def gem_home(ctx)
+        ctx.getenv("GEM_HOME") || apply_gem_home(ctx)
+      end
+
+      def gem_path(ctx)
+        ctx.getenv("GEM_PATH") || apply_gem_path(ctx)
+      end
+
+      private
+
+      def apply_gem_home(ctx)
+        path = ""
+        # extract GEM_HOME from `gem environment home` command
+        out, stat = ctx.capture2e("gem", "environment", "home")
+        path = out&.empty? ? "" : out.strip if stat.success?
+        # fallback if return from `gem environment home` is empty (somewhat unlikely)
+        path = fallback_gem_home_path(ctx) if path.empty?
+        # fallback if path isn't writable (if using a system installed ruby)
+        path = fallback_gem_home_path(ctx) unless File.writable?(path)
+        ctx.mkdir_p(path) unless Dir.exist?(path)
+        ctx.debug(ctx.message("rails.gem.setting_gem_home", path))
+        ctx.setenv("GEM_HOME", path)
+      end
+
+      def apply_gem_path(ctx)
+        path = ""
+        out, stat = ctx.capture2e("gem", "environment", "path")
+        path = out&.empty? ? "" : out.strip if stat.success?
+        # usually GEM_PATH already contains GEM_HOME
+        # if gem_home() falls back to our fallback path, we need to add it
+        path = gem_home(ctx) + File::PATH_SEPARATOR + path unless path.include?(gem_home(ctx))
+        ctx.debug(ctx.message("rails.gem.setting_gem_path", path))
+        ctx.setenv("GEM_PATH", path)
+      end
+
+      def fallback_gem_home_path(ctx)
+        File.join(ctx.getenv("HOME"), ".gem", "ruby", RUBY_VERSION)
+      end
+    end
+
+    def installed?
+      found = false
+      paths = self.class.gem_path(ctx).split(File::PATH_SEPARATOR)
+      paths.each do |path|
+        ctx.debug(ctx.message("rails.gem.checking_installation_path", "#{path}/gems/", name))
+        found = !!Dir.glob("#{path}/gems/#{name}-*").detect do |f|
+          gem_satisfies_version?(f)
+        end
+        break if found
+      end
+      found
+    end
+
+    def install!
+      spin = CLI::UI::SpinGroup.new
+      spin.add(ctx.message("rails.gem.installing", name)) do |spinner|
+        args = ["#{ENV["RUBY_BINDIR"]}gem", "install", name]
+        unless version.nil?
+          if ctx.windows? && version.include?("~")
+            args.push("-v", "\"#{version}\"")
+          else
+            args.push("-v", version)
+          end
+        end
+        ctx.system(*args)
+        spinner.update_title(ctx.message("rails.gem.installed", name))
+      end
+      spin.wait
+    end
+
+    def gem_satisfies_version?(path)
+      if version
+        # there was a specific version given during new(), so
+        # check version of gem found to determine match
+        require "semantic/semantic"
+        found_version, _ = path.match(%r{/#{Regexp.quote(name)}-(\d\.\d\.\d)})&.captures
+        found_version.nil? ? false : Semantic::Version.new(found_version).satisfies?(version)
+      else
+        # otherwise ignore the actual version number,
+        # just check there's an initial digit
+        %r{/#{Regexp.quote(name)}-\d}.match?(path)
+      end
+    end
+  end
+end

package/assets/cli-ruby/lib/project_types/rails/messages/messages.rb

@@ -0,0 +1,101 @@
+# frozen_string_literal: true
+
+module Rails
+  module Messages
+    MESSAGES = {
+      rails: {
+        help: <<~HELP,
+          Suite of commands for developing Ruby on Rails apps. See {{command:%1$s app rails <command> --help}} for usage of each command.
+            Usage: {{command:%1$s app rails [ %2$s ]}}
+        HELP
+
+        error: {
+          generic: "Error",
+        },
+
+        gem: {
+          checking_installation_path: "Checking path %s for gem %s",
+          installed: "Installed %s gem",
+          installed_debug: "%s installed: %s",
+          installing: "Installing %s gem…",
+          setting_gem_home: "GEM_HOME being set to %s",
+          setting_gem_path: "GEM_PATH being set to %s",
+        },
+        deploy: {
+          help: <<~HELP,
+            Deploy the current Rails project to a hosting service. Heroku ({{underline:https://www.heroku.com}}) is currently the only option, but more will be added in the future.
+              Usage: {{command:%s app rails deploy [ heroku ]}}
+          HELP
+          extended_help: <<~HELP,
+            {{bold:Subcommands:}}
+              {{cyan:heroku}}: Deploys the current Rails project to Heroku.
+                Usage: {{command:%s app rails deploy heroku}}
+          HELP
+        },
+
+        generate: {
+          help: <<~HELP,
+            Generate code in your Rails project. Currently supports generating new webhooks.
+              Usage: {{command:%s app rails generate [ webhook ]}}
+          HELP
+          extended_help: <<~EXAMPLES,
+            {{bold:Examples:}}
+              {{cyan:%s generate webhook PRODUCTS_CREATE}}
+                Generate and register a new webhook that will be called every time a new product is created on your store.
+          EXAMPLES
+
+          error: {
+            name_exists: "%s already exists!",
+            generic: "Error generating %s",
+          },
+
+          webhook: {
+            help: <<~HELP,
+              Generate and register a new webhook that listens for the specified Shopify store event.
+                Usage: {{command:%s app rails generate webhook <type>}}
+            HELP
+
+            select: "What type of webhook would you like to create?",
+            selected: "Generating webhook: %s",
+          },
+        },
+        forms: {
+          create: {
+            error: {
+              invalid_app_name: "App name cannot contain 'Shopify'",
+              invalid_app_type: "Invalid app type %s",
+              invalid_db_type: "Invalid database type %s",
+            },
+            app_name: "App name",
+            app_type: {
+              select: "What type of app are you building?",
+              select_public: "Public: An app built for a wide merchant audience.",
+              select_custom: "Custom: An app custom built for a single client.",
+              selected: "App type {{green:%s}}",
+            },
+            db: {
+              want_select: <<~WANT_SELECT,
+                Would you like to select what database type to use now? (SQLite is the default)
+                If you want to change this in the future, run {{command:rails db:system:change --to=[new_db_type]}}. For more info:
+                {{underline:https://gorails.com/episodes/rails-6-db-system-change-command}}
+              WANT_SELECT
+              select: "What database type would you like to use? Please ensure the database is installed.",
+              select_sqlite3: "SQLite (default)",
+              select_mysql: "MySQL",
+              select_postgresql: "PostgreSQL",
+              select_oracle: "Oracle",
+              select_frontbase: "FrontBase",
+              select_ibm_db: "IBM_DB",
+              select_sqlserver: "SQL Server",
+              select_jdbcmysql: "JDBC MySQL",
+              select_jdbcsqlite3: "JDBC SQlite",
+              select_jdbcpostgresql: "JDBC PostgreSQL",
+              select_jdbc: "JDBC",
+              selected: "Database Type {{green:%s}}",
+            },
+          },
+        },
+      },
+    }.freeze
+  end
+end

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

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Script
+  class Project < ShopifyCLI::ProjectType
+    hidden_feature(feature_set: :script_project)
+
+    require Project.project_filepath("messages/messages")
+    register_messages(Script::Messages::MESSAGES)
+  end
+
+  # define/autoload project specific Commands
+  class Command < ShopifyCLI::Command::ProjectCommand
+    hidden_feature(feature_set: :script_project)
+    subcommand :Create, "create", Project.project_filepath("commands/create")
+    subcommand :Push, "push", Project.project_filepath("commands/push")
+    subcommand :Connect, "connect", Project.project_filepath("commands/connect")
+    subcommand :Javy, "javy", Project.project_filepath("commands/javy")
+  end
+  ShopifyCLI::Commands.register("Script::Command", "script")
+
+  module Loaders
+    autoload :Project, Script::Project.project_filepath("loaders/project")
+    autoload :SpecificationHandler, Script::Project.project_filepath("loaders/specification_handler")
+  end
+
+  class ScriptProjectError < StandardError; end
+end

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

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+module Script
+  class Command
+    class Connect < ShopifyCLI::Command::SubCommand
+      hidden_feature
+
+      def call(_args, _)
+        @ctx.abort(@ctx.message("script.deprecated"))
+      end
+
+      def self.help
+        ShopifyCLI::Context.new.message("script.deprecated")
+      end
+    end
+  end
+end

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

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Script
+  class Command
+    class Create < ShopifyCLI::Command::SubCommand
+      hidden_feature
+
+      options do |parser, flags|
+        parser.on("--title=TITLE") { |title| flags[:title] = title }
+        parser.on("--api=API_NAME") { |ep_name| flags[:extension_point] = ep_name }
+        parser.on("--language=LANGUAGE") { |language| flags[:language] = language }
+        parser.on("--branch=BRANCH") { |branch| flags[:branch] = branch }
+      end
+
+      def call(_args, _)
+        @ctx.abort(@ctx.message("script.deprecated"))
+      end
+
+      def self.help
+        ShopifyCLI::Context.new.message("script.deprecated")
+      end
+    end
+  end
+end

package/assets/cli-ruby/lib/project_types/script/commands/javy.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+require "shopify_cli"
+require_relative "../../../../ext/javy/javy.rb"
+
+module Script
+  class Command
+    class Javy < ShopifyCLI::Command::SubCommand
+      hidden_feature
+
+      options do |parser, flags|
+        parser.on("--in=IN") { |in_file| flags[:in_file] = in_file }
+        parser.on("--out=OUT") { |out_file| flags[:out_file] = out_file }
+      end
+
+      def call(_args, _)
+        @ctx.abort(@ctx.message("script.deprecated"))
+      end
+
+      def self.help
+        ShopifyCLI::Context.new.message("script.deprecated")
+      end
+    end
+  end
+end

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

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Script
+  class Command
+    class Push < ShopifyCLI::Command::SubCommand
+      hidden_feature
+
+      options do |parser, flags|
+        parser.on("--force") { |t| flags[:force] = t }
+        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("--uuid=UUID") do |uuid|
+          flags[:uuid] = uuid.gsub('""', "")
+        end
+      end
+
+      def call(_args, _)
+        @ctx.abort(@ctx.message("script.deprecated"))
+      end
+
+      def self.help
+        ShopifyCLI::Context.new.message("script.deprecated")
+      end
+    end
+  end
+end