@shopify/cli-kit 3.39.0 → 3.40.1

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

@@ -0,0 +1,147 @@
+require "semantic/semantic"
+
+module ShopifyCLI
+  module Services
+    module App
+      module Create
+        class PHPService < BaseService
+          attr_reader :name, :organization_id, :store_domain, :type, :verbose, :context
+
+          def initialize(name:, organization_id:, store_domain:, type:, verbose:, context:)
+            @name = name
+            @organization_id = organization_id
+            @store_domain = store_domain
+            @type = type
+            @verbose = verbose
+            @context = context
+            super()
+          end
+
+          def call
+            form = PHP::Forms::Create.ask(context, [], {
+              name: name,
+              organization_id: organization_id,
+              shop_domain: store_domain,
+              type: type,
+              verbose: verbose,
+            })
+            raise ShopifyCLI::AbortSilent if form.nil?
+
+            check_php
+            check_composer
+            check_npm
+            app_id = build(form)
+
+            ShopifyCLI::Project.write(
+              context,
+              project_type: "php",
+              organization_id: form.organization_id,
+            )
+
+            partners_url = ShopifyCLI::PartnersAPI.partners_url_for(form.organization_id, app_id)
+
+            context.puts(context.message("apps.create.info.created", form.name, partners_url))
+            context.puts(context.message("apps.create.info.serve", form.name, ShopifyCLI::TOOL_NAME))
+            unless ShopifyCLI::Shopifolk.acting_as_shopify_organization?
+              context.puts(context.message("apps.create.info.install", partners_url, form.name))
+            end
+          end
+
+          private
+
+          def check_php
+            cmd_path = context.which("php")
+            context.abort(context.message("core.app.create.php.error.php_required")) if cmd_path.nil?
+
+            version, stat = context.capture2e("php", "-r", "echo phpversion();")
+            context.abort(context.message("core.app.create.php.error.php_version_failure")) unless stat.success?
+
+            if ::Semantic::Version.new(version) < ::Semantic::Version.new("7.3.0")
+              context.abort(context.message("core.app.create.php.error.php_version_too_low", "7.3"))
+            end
+
+            context.done(context.message("core.app.create.php.php_version", version))
+          end
+
+          def check_composer
+            cmd_path = context.which("composer")
+            context.abort(context.message("core.app.create.php.error.composer_required")) if cmd_path.nil?
+          end
+
+          def check_npm
+            version = ShopifyCLI::Environment.npm_version(context: context)
+            context.done(context.message("core.app.create.php.npm_version", version))
+          end
+
+          def build(form)
+            ShopifyCLI::Git.clone("https://github.com/Shopify/shopify-app-template-php.git#cli_two", form.name)
+
+            context.root = File.join(context.root, form.name)
+            context.chdir(context.root)
+
+            api_client = ShopifyCLI::Tasks::CreateApiClient.call(
+              context,
+              org_id: form.organization_id,
+              title: form.name,
+              type: form.type,
+            )
+
+            # Override the example settings with our own
+            context.cp(".env.example", ".env")
+
+            env_file = ShopifyCLI::Resources::EnvFile.read
+            env_file.api_key = api_client["apiKey"]
+            env_file.secret = api_client["apiSecretKeys"].first["secret"]
+            env_file.shop = form.shop_domain
+            env_file.host = "localhost"
+            env_file.scopes = "write_products,write_draft_orders,write_customers"
+            env_file.extra["DB_DATABASE"] = File.join(context.root, env_file.extra["DB_DATABASE"])
+            env_file.write(context)
+
+            ShopifyCLI::PHPDeps.install(context, verbose)
+
+            set_npm_config
+            ShopifyCLI::JsDeps.install(context, verbose)
+
+            title = context.message("core.app.create.php.app_setting_up")
+            success = context.message("core.app.create.php.app_set_up")
+            failure = context.message("core.app.create.php.error.app_setup")
+            CLI::UI::Frame.open(title, success_text: success, failure_text: failure) do
+              FileUtils.touch(env_file.extra["DB_DATABASE"])
+              context.system("php", "artisan", "key:generate")
+              context.system("php", "artisan", "migrate")
+            end
+
+            begin
+              context.rm_r(".git")
+              context.rm_r(".github")
+            rescue Errno::ENOENT => e
+              context.debug(e)
+            end
+
+            api_client["id"]
+          end
+
+          def set_npm_config
+            # check available npmrc (either user or system) for production registry
+            registry, _ = context.capture2("npm config get @shopify:registry")
+            return if registry.include?("https://registry.yarnpkg.com")
+
+            # available npmrc doesn't have production registry =>
+            # set a project-based .npmrc
+            context.system(
+              "npm",
+              "--userconfig",
+              "./.npmrc",
+              "config",
+              "set",
+              "@shopify:registry",
+              "https://registry.yarnpkg.com",
+              chdir: context.root
+            )
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,239 @@
+require "semantic/semantic"
+
+module ShopifyCLI
+  module Services
+    module App
+      module Create
+        class RailsService < BaseService
+          USER_AGENT_CODE = <<~USERAGENT
+            module ShopifyAPI
+              class Base < ActiveResource::Base
+                self.headers['User-Agent'] << " | ShopifyApp/\#{ShopifyApp::VERSION} | Shopify CLI"
+              end
+            end
+          USERAGENT
+
+          DEFAULT_RAILS_FLAGS = %w(--skip-spring)
+
+          attr_reader :name, :organization_id, :store_domain, :type, :db, :rails_opts, :context
+
+          def initialize(name:, organization_id:, store_domain:, type:, db:, rails_opts:, context:)
+            @name = name
+            @organization_id = organization_id
+            @store_domain = store_domain
+            @type = type
+            @db = db
+            @rails_opts = rails_opts
+            @context = context
+            super()
+          end
+
+          def call
+            form_options = {
+              name: name,
+              organization_id: organization_id,
+              shop_domain: store_domain,
+              type: type,
+            }
+            form_options[:db] = db unless db.nil?
+            form_options[:rails_opts] = rails_opts unless rails_opts.nil?
+            form = form_data(form_options)
+
+            raise ShopifyCLI::AbortSilent if form.nil?
+
+            check_dependencies
+
+            build(form.name, form.db)
+            set_custom_ua
+            ShopifyCLI::Project.write(
+              context,
+              project_type: "rails",
+              organization_id: form.organization_id,
+            )
+
+            api_client = if ShopifyCLI::Environment.acceptance_test?
+              {
+                "apiKey" => "public_api_key",
+                "apiSecretKeys" => [
+                  {
+                    "secret" => "api_secret_key",
+                  },
+                ],
+              }
+            else
+              ShopifyCLI::Tasks::CreateApiClient.call(
+                context,
+                org_id: form.organization_id,
+                title: form.name,
+                type: form.type,
+              )
+            end
+
+            ShopifyCLI::Resources::EnvFile.new(
+              api_key: api_client["apiKey"],
+              secret: api_client["apiSecretKeys"].first["secret"],
+              shop: form.shop_domain,
+              scopes: "write_products,write_customers,write_draft_orders",
+            ).write(context)
+
+            partners_url = ShopifyCLI::PartnersAPI.partners_url_for(form.organization_id, api_client["id"])
+
+            context.puts(context.message("apps.create.info.created", form.name, partners_url))
+            context.puts(context.message("apps.create.info.serve", form.name, ShopifyCLI::TOOL_NAME))
+            unless ShopifyCLI::Shopifolk.acting_as_shopify_organization?
+              context.puts(context.message("apps.create.info.install", partners_url, form.name))
+            end
+          end
+
+          private
+
+          def form_data(form_options)
+            if ShopifyCLI::Environment.acceptance_test?
+              Struct.new(:name, :organization_id, :type, :shop_domain, :db, keyword_init: true).new(
+                name: form_options[:name],
+                organization_id: "123",
+                shop_domain: "test.shopify.io",
+                type: "public",
+                db: form_options[:db]
+              )
+            else
+              Rails::Forms::Create.ask(context, [], form_options)
+            end
+          end
+
+          def check_dependencies
+            check_ruby
+            check_node
+            check_yarn
+          end
+
+          def check_ruby
+            ruby_version = Environment.ruby_version(context: context)
+            return if ruby_version.satisfies?("~>2.5") ||
+              ruby_version.satisfies?("~>3.0.0") ||
+              ruby_version.satisfies?("~>3.1.0")
+            context.abort(context.message("core.app.create.rails.error.invalid_ruby_version"))
+          end
+
+          def check_node
+            cmd_path = context.which("node")
+            if cmd_path.nil?
+              context.abort(context.message("core.app.create.rails.error.node_required")) unless context.windows?
+              context.puts("{{x}} {{red:" + context.message("core.app.create.rails.error.node_required") + "}}")
+              context.puts(context.message("core.app.create.rails.info.open_new_shell", "node"))
+              raise ShopifyCLI::AbortSilent
+            end
+
+            version, stat = context.capture2e("node", "-v")
+            unless stat.success?
+              context.abort(context.message("core.app.create.rails.error.node_version_failure")) unless context.windows?
+              # execution stops above if not Windows
+              context.puts("{{x}} {{red:" + context.message("core.app.create.rails.error.node_version_failure") + "}}")
+              context.puts(context.message("core.app.create.rails.info.open_new_shell", "node"))
+              raise ShopifyCLI::AbortSilent
+            end
+
+            context.done(context.message("core.app.create.rails.node_version", version))
+          end
+
+          def check_yarn
+            cmd_path = context.which("yarn")
+            if cmd_path.nil?
+              context.abort(context.message("core.app.create.rails.error.yarn_required")) unless context.windows?
+              context.puts("{{x}} {{red:" + context.message("core.app.create.rails.error.yarn_required") + "}}")
+              context.puts(context.message("core.app.create.rails.info.open_new_shell", "yarn"))
+              raise ShopifyCLI::AbortSilent
+            end
+
+            version, stat = context.capture2e("yarn", "-v")
+            unless stat.success?
+              context.abort(context.message("core.app.create.rails.error.yarn_version_failure")) unless context.windows?
+              context.puts("{{x}} {{red:" + context.message("core.app.create.rails.error.yarn_version_failure") + "}}")
+              context.puts(context.message("core.app.create.rails.info.open_new_shell", "yarn"))
+              raise ShopifyCLI::AbortSilent
+            end
+
+            context.done(context.message("core.app.create.rails.yarn_version", version))
+          end
+
+          def build(name, db)
+            unless install_gem("rails")
+              context.abort(context.message("core.app.create.rails.error.install_failure", "rails"))
+            end
+
+            unless install_gem("bundler", "~>2.0")
+              context.abort(context.message("core.app.create.rails.error.install_failure", "bundler ~>2.0"))
+            end
+
+            full_path = File.join(context.root, name)
+            context.abort(context.message("core.app.create.rails.error.dir_exists", name)) if Dir.exist?(full_path)
+
+            CLI::UI::Frame.open(context.message("core.app.create.rails.generating_app", name)) do
+              new_command = %w(rails new)
+              new_command << name
+              new_command += DEFAULT_RAILS_FLAGS
+              new_command << "--database=#{db}"
+              new_command += rails_opts.split unless rails_opts.nil?
+
+              syscall(new_command)
+            end
+
+            context.root = full_path
+
+            File.open(File.join(context.root, ".gitignore"), "a") { |f| f.write(".env") }
+
+            context.puts(context.message("core.app.create.rails.adding_shopify_gem"))
+            File.open(File.join(context.root, "Gemfile"), "a") do |f|
+              f.puts "\ngem 'shopify_app', '~>19.0.1'"
+            end
+            CLI::UI::Frame.open(context.message("core.app.create.rails.running_bundle_install")) do
+              syscall(%w(bundle install))
+            end
+
+            CLI::UI::Frame.open(context.message("core.app.create.rails.running_generator")) do
+              syscall(%w(rails generate shopify_app --new-shopify-cli-app))
+            end
+
+            CLI::UI::Frame.open(context.message("core.app.create.rails.running_migrations")) do
+              syscall(%w(rails db:create))
+              syscall(%w(rails db:migrate RAILS_ENV=development))
+            end
+
+            if install_webpacker?
+              CLI::UI::Frame.open(context.message("core.app.create.rails.running_webpacker_install")) do
+                syscall(%w(rails webpacker:install))
+              end
+            end
+          end
+
+          def set_custom_ua
+            requires_ua_file = Dir.chdir(context.root) do
+              context.ruby_gem_version("shopify_app") < ::Semantic::Version.new("19.0.0")
+            end
+
+            return unless requires_ua_file
+
+            ua_path = File.join("config", "initializers", "user_agent.rb")
+            context.write(ua_path, USER_AGENT_CODE)
+          end
+
+          def syscall(args)
+            args[0] = Rails::Gem.binary_path_for(context, args[0])
+            context.system(*args, chdir: context.root)
+          end
+
+          def install_gem(name, version = nil)
+            Rails::Gem.install(context, name, version)
+          end
+
+          def install_webpacker?
+            rails_version = Environment.rails_version(context: context)
+            webpacker_config = File.exist?(File.join(context.root, "config/webpacker.yml"))
+
+            rails_version < ::Semantic::Version.new("7.0.0") && !webpacker_config
+          end
+        end
+      end
+    end
+  end
+end

package/assets/cli-ruby/lib/shopify_cli/services/app/deploy/heroku/node_service.rb

@@ -0,0 +1,101 @@
+module ShopifyCLI
+  module Services
+    module App
+      module Deploy
+        module Heroku
+          class NodeService < BaseService
+            attr_reader :context
+
+            def initialize(context:)
+              @context = context
+              super()
+            end
+
+            def call
+              spin_group = CLI::UI::SpinGroup.new
+              heroku_service = ShopifyCLI::Heroku.new(context)
+
+              spin_group.add(context.message("core.app.deploy.heroku.downloading")) do |spinner|
+                heroku_service.download
+                spinner.update_title(context.message("core.app.deploy.heroku.downloaded"))
+              end
+              spin_group.wait
+
+              install_message = context.message(
+                context.windows? ? "core.app.deploy.heroku.installing_windows" : "core.app.deploy.heroku.installing"
+              )
+              spin_group.add(install_message) do |spinner|
+                heroku_service.install
+                spinner.update_title(context.message("core.app.deploy.heroku.installed"))
+              end
+              spin_group.wait
+
+              spin_group.add(context.message("core.app.deploy.heroku.git.checking")) do |spinner|
+                ShopifyCLI::Git.init(context)
+                spinner.update_title(context.message("core.app.deploy.heroku.git.initialized"))
+              end
+              spin_group.wait
+
+              if (account = heroku_service.whoami)
+                context.puts(context.message("core.app.deploy.heroku.authenticated_with_account", account))
+              else
+                CLI::UI::Frame.open(
+                  context.message("core.app.deploy.heroku.authenticating"),
+                  success_text: context.message("core.app.deploy.heroku.authenticated")
+                ) do
+                  heroku_service.authenticate
+                end
+              end
+
+              if (app_name = heroku_service.app)
+                context.puts(context.message("core.app.deploy.heroku.app.selected", app_name))
+              else
+                app_type = CLI::UI::Prompt.ask(context.message("core.app.deploy.heroku.app.no_apps_found")) do |handler|
+                  handler.option(context.message("core.app.deploy.heroku.app.create")) { :new }
+                  handler.option(context.message("core.app.deploy.heroku.app.select")) { :existing }
+                end
+
+                if app_type == :existing
+                  app_name = CLI::UI::Prompt.ask(context.message("core.app.deploy.heroku.app.name"))
+                  CLI::UI::Frame.open(
+                    context.message("core.app.deploy.heroku.app.selecting", app_name),
+                    success_text: context.message("core.app.deploy.heroku.app.selected", app_name)
+                  ) do
+                    heroku_service.select_existing_app(app_name)
+                  end
+                elsif app_type == :new
+                  CLI::UI::Frame.open(
+                    context.message("core.app.deploy.heroku.app.creating"),
+                    success_text: context.message("core.app.deploy.heroku.app.created")
+                  ) do
+                    heroku_service.create_new_app
+                  end
+                end
+              end
+
+              branches = ShopifyCLI::Git.branches(context)
+              if branches.length == 1
+                branch_to_deploy = branches[0]
+                context.puts(context.message("core.app.deploy.heroku.git.branch_selected", branch_to_deploy))
+              else
+                prompt_question = context.message("core.app.deploy.heroku.git.what_branch")
+                branch_to_deploy = CLI::UI::Prompt.ask(prompt_question) do |handler|
+                  branches.each do |branch|
+                    handler.option(branch) { branch }
+                  end
+                end
+              end
+
+              CLI::UI::Frame.open(
+                context.message("core.app.deploy.heroku.deploying"),
+                success_text: context.message("core.app.deploy.heroku.deployed")
+              ) do
+                heroku_service.deploy(branch_to_deploy)
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

package/assets/cli-ruby/lib/shopify_cli/services/app/deploy/heroku/php_service.rb

@@ -0,0 +1,135 @@
+module ShopifyCLI
+  module Services
+    module App
+      module Deploy
+        module Heroku
+          class PHPService < BaseService
+            attr_reader :context
+
+            def initialize(context:)
+              @context = context
+              super()
+            end
+
+            def call
+              spin_group = CLI::UI::SpinGroup.new
+              heroku_service = ShopifyCLI::Heroku.new(context)
+
+              spin_group.add(context.message("core.app.deploy.heroku.downloading")) do |spinner|
+                heroku_service.download
+                spinner.update_title(context.message("core.app.deploy.heroku.downloaded"))
+              end
+              spin_group.wait
+
+              install_message = context.message(
+                context.windows? ? "core.app.deploy.heroku.installing_windows" : "core.app.deploy.heroku.installing"
+              )
+              spin_group.add(install_message) do |spinner|
+                heroku_service.install
+                spinner.update_title(context.message("core.app.deploy.heroku.installed"))
+              end
+              spin_group.wait
+
+              spin_group.add(context.message("core.app.deploy.heroku.git.checking")) do |spinner|
+                ShopifyCLI::Git.init(context)
+                spinner.update_title(context.message("core.app.deploy.heroku.git.initialized"))
+              end
+              spin_group.wait
+
+              if (account = heroku_service.whoami)
+                context.puts(context.message("core.app.deploy.heroku.authenticated_with_account", account))
+              else
+                CLI::UI::Frame.open(
+                  context.message("core.app.deploy.heroku.authenticating"),
+                  success_text: context.message("core.app.deploy.heroku.authenticated")
+                ) do
+                  heroku_service.authenticate
+                end
+              end
+
+              if (app_name = heroku_service.app)
+                context.puts(context.message("core.app.deploy.heroku.app.selected", app_name))
+              else
+                app_type = CLI::UI::Prompt.ask(context.message("core.app.deploy.heroku.app.no_apps_found")) do |handler|
+                  handler.option(context.message("core.app.deploy.heroku.app.create")) { :new }
+                  handler.option(context.message("core.app.deploy.heroku.app.select")) { :existing }
+                end
+
+                if app_type == :existing
+                  app_name = CLI::UI::Prompt.ask(context.message("core.app.deploy.heroku.app.name"))
+                  CLI::UI::Frame.open(
+                    context.message("core.app.deploy.heroku.app.selecting", app_name),
+                    success_text: context.message("core.app.deploy.heroku.app.selected", app_name)
+                  ) do
+                    heroku_service.select_existing_app(app_name)
+                  end
+                elsif app_type == :new
+                  CLI::UI::Frame.open(
+                    context.message("core.app.deploy.heroku.app.creating"),
+                    success_text: context.message("core.app.deploy.heroku.app.created")
+                  ) do
+                    heroku_service.create_new_app
+                    app_name = heroku_service.app
+                  end
+                end
+              end
+
+              branches = ShopifyCLI::Git.branches(context)
+              if branches.length == 1
+                branch_to_deploy = branches[0]
+                context.puts(context.message("core.app.deploy.heroku.git.branch_selected", branch_to_deploy))
+              else
+                prompt_question = context.message("core.app.deploy.heroku.git.what_branch")
+                branch_to_deploy = CLI::UI::Prompt.ask(prompt_question) do |handler|
+                  branches.each do |branch|
+                    handler.option(branch) { branch }
+                  end
+                end
+              end
+
+              app_url = "https://#{app_name}.herokuapp.com"
+
+              CLI::UI::Frame.open(
+                context.message("core.app.deploy.heroku.app.setting_configs"),
+                success_text: context.message("core.app.deploy.heroku.app.configs_set")
+              ) do
+                allowed_configs = [/SHOPIFY_API_KEY/, /SHOPIFY_API_SECRET/, /SCOPES/, /HOST/]
+
+                ShopifyCLI::Project.current.env.to_h.each do |config, value|
+                  next unless allowed_configs.any? { |pattern| pattern.match?(config) }
+
+                  value = app_url if config == "HOST"
+
+                  current = heroku_service.get_config(config)
+                  heroku_service.set_config(config, value) if current.nil? || current != value
+                end
+
+                current_key = heroku_service.get_config("APP_KEY")
+                if current_key.nil? || current_key.empty?
+                  output, status = context.capture2e("php", "artisan", "key:generate", "--show")
+
+                  abort_message = context.message("core.app.deploy.heroku.php.error.generate_app_key")
+                  context.abort(abort_message) unless status.success?
+
+                  heroku_service.set_config("APP_KEY", output.strip) if status.success?
+                end
+
+                heroku_service.add_buildpacks(["heroku/php", "heroku/nodejs"])
+              end
+
+              CLI::UI::Frame.open(
+                context.message("core.app.deploy.heroku.deploying"),
+                success_text: context.message("core.app.deploy.heroku.deployed")
+              ) do
+                heroku_service.deploy(branch_to_deploy)
+              end
+
+              heroku_command = heroku_service.heroku_command
+              context.puts(context.message("core.app.deploy.heroku.php.post_deploy", app_url, heroku_command))
+            end
+          end
+        end
+      end
+    end
+  end
+end