shopify-cli 2.6.6 → 2.7.0

data/lib/shopify_cli/services/app/create/rails_service.rb

@@ -0,0 +1,213 @@
+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)
+
+            ruby_version = Rails::Ruby.version(context)
+            context.abort(context.message("core.app.create.rails.error.invalid_ruby_version")) unless
+              ruby_version.satisfies?("~>2.5") || ruby_version.satisfies?("~>3.0.0")
+
+            check_node
+            check_yarn
+
+            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_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)
+            context.abort(context.message("core.app.create.rails.error.install_failure",
+              "rails")) unless install_gem("rails",
+                "<6.1")
+            context.abort(context.message("core.app.create.rails.error.install_failure", "bundler ~>2.0")) unless
+              install_gem("bundler", "~>2.0")
+
+            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 += DEFAULT_RAILS_FLAGS
+              new_command << "--database=#{db}"
+              new_command += rails_opts.split unless rails_opts.nil?
+              new_command << name
+
+              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', '>=17.0.3'"
+            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
+
+            unless File.exist?(File.join(context.root, "config/webpacker.yml"))
+              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
+            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
+        end
+      end
+    end
+  end
+end

data/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

data/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

data/lib/shopify_cli/services/app/deploy/heroku/rails_service.rb

@@ -0,0 +1,120 @@
+module ShopifyCLI
+  module Services
+    module App
+      module Deploy
+        module Heroku
+          class RailsService < BaseService
+            DB_CHECK_CMD = 'bundle exec rails runner "puts ActiveRecord::Base.connection.adapter_name.downcase"'
+
+            attr_reader :context
+
+            def initialize(context:)
+              @context = context
+              super()
+            end
+
+            def call
+              CLI::UI::Frame.open(context.message("core.app.deploy.heroku.rails.db_check.validating")) do
+                CLI::UI::Spinner.spin(context.message("core.app.deploy.heroku.rails.db_check.checking")) do |spinner|
+                  db_type, err = check_db(context)
+                  context.abort(context.message(err)) unless err.nil?
+                  spinner.update_title(context.message("core.app.deploy.heroku.rails.db_check.validated", db_type))
+                end
+                true
+              end
+
+              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
+
+              spin_group.add(context.message("core.app.deploy.heroku.installing")) do |spinner|
+                heroku_service.install
+                spinner.update_title(context.message("core.app.deploy.heroku.installed"))
+              end
+              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
+
+            private
+
+            def check_db(context)
+              out, stat = context.capture2e(DB_CHECK_CMD)
+              if stat.success? && out.strip == "sqlite"
+                ["sqlite", "core.app.deploy.heroku.rails.db_check.sqlite"]
+              elsif !stat.success?
+                [nil, "core.app.deploy.heroku.rails.db_check.problem"]
+              else
+                [out.strip, nil]
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/shopify_cli/services/app/open_service.rb

@@ -0,0 +1,19 @@
+module ShopifyCLI
+  module Services
+    module App
+      class OpenService < BaseService
+        attr_reader :project, :context
+
+        def initialize(project:, context:)
+          @project = project
+          @context = context
+          super()
+        end
+
+        def call
+          context.open_url!("#{project.env.host}/login?shop=#{project.env.shop}")
+        end
+      end
+    end
+  end
+end

data/lib/shopify_cli/services/app/serve/node_service.rb

@@ -0,0 +1,42 @@
+module ShopifyCLI
+  module Services
+    module App
+      module Serve
+        class NodeService < BaseService
+          attr_accessor :host, :port, :context
+
+          def initialize(host:, port:, context:)
+            @host = host
+            @port = port
+            @context = context
+            super()
+          end
+
+          def call
+            project = ShopifyCLI::Project.current
+            url = host || ShopifyCLI::Tunnel.start(context)
+            raise ShopifyCLI::Abort,
+              context.message("core.app.serve.error.host_must_be_https") if url.match(/^https/i).nil?
+            project.env.update(context, :host, url)
+            ShopifyCLI::Tasks::UpdateDashboardURLS.call(
+              context,
+              url: url,
+              callback_url: "/auth/callback",
+            )
+
+            if project.env.shop
+              project_url = "#{project.env.host}/auth?shop=#{project.env.shop}"
+              context.puts("\n" + context.message("core.app.serve.open_info", project_url) + "\n")
+            end
+
+            CLI::UI::Frame.open(context.message("core.app.serve.running_server")) do
+              env = project.env.to_h
+              env["PORT"] = port.to_s
+              context.system("npm run dev", env: env)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/shopify_cli/services/app/serve/php_service.rb

@@ -0,0 +1,46 @@
+module ShopifyCLI
+  module Services
+    module App
+      module Serve
+        class PHPService < BaseService
+          attr_accessor :host, :port, :context
+
+          def initialize(host:, port:, context:)
+            @host = host
+            @port = port
+            @context = context
+            super()
+          end
+
+          def call
+            project = ShopifyCLI::Project.current
+            url = host || ShopifyCLI::Tunnel.start(context, port: port)
+            raise ShopifyCLI::Abort,
+              context.message("core.app.serve.error.host_must_be_https") if url.match(/^https/i).nil?
+            project.env.update(context, :host, url)
+            ShopifyCLI::Tasks::UpdateDashboardURLS.call(
+              context,
+              url: url,
+              callback_url: "/auth/callback",
+            )
+
+            if project.env.shop
+              project_url = "#{project.env.host}/login?shop=#{project.env.shop}"
+              context.puts("\n" + context.message("core.app.serve.open_info", project_url) + "\n")
+            end
+
+            CLI::UI::Frame.open(context.message("core.app.serve.running_server")) do
+              if ShopifyCLI::ProcessSupervision.running?(:npm_watch)
+                ShopifyCLI::ProcessSupervision.stop(:npm_watch)
+              end
+              ShopifyCLI::ProcessSupervision.start(:npm_watch, "npm run watch", force_spawn: true)
+
+              env = project.env.to_h
+              context.system("php", "artisan", "serve", "--port", port.to_s, env: env)
+            end
+          end
+        end
+      end
+    end
+  end
+end