@shopify/cli-kit 3.38.0 → 3.40.0

package/assets/cli-ruby/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

package/assets/cli-ruby/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

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

@@ -0,0 +1,19 @@
+module ShopifyCLI
+  module Services
+    module App
+      module Serve
+        class NodeService < ServeService
+          def call
+            generate_url
+
+            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

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

@@ -0,0 +1,23 @@
+module ShopifyCLI
+  module Services
+    module App
+      module Serve
+        class PHPService < ServeService
+          def call
+            generate_url
+
+            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

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

@@ -0,0 +1,28 @@
+module ShopifyCLI
+  module Services
+    module App
+      module Serve
+        class RailsService < ServeService
+          def call
+            generate_url
+
+            CLI::UI::Frame.open(context.message("core.app.serve.running_server")) do
+              original_env = JSON.parse(ENV["ORIGINAL_ENV"] || "{}")
+              env = original_env.merge(ShopifyCLI::Project.current.env.to_h)
+              env.delete("HOST") if context.ruby_gem_version("shopify_app") < ::Semantic::Version.new("19.0.0")
+              env["PORT"] = port.to_s
+              env["GEM_PATH"] =
+                [env["GEM_PATH"], Rails::Gem.gem_path(context)].compact
+                  .join(CLI::UI::OS.current.path_separator)
+              if context.windows?
+                context.system("ruby bin\\rails server", env: env)
+              else
+                context.system("bin/rails server", env: env)
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

package/assets/cli-ruby/lib/shopify_cli/services/app/serve/serve_service.rb

@@ -0,0 +1,57 @@
+module ShopifyCLI
+  module Services
+    module App
+      module Serve
+        class ServeService < BaseService
+          attr_accessor :host, :port, :no_update, :context
+
+          def initialize(host:, port:, no_update:, context:)
+            @host = host
+            @port = port
+            @no_update = no_update
+            @context = context
+            super()
+          end
+
+          def call
+            raise NotImplementedError
+          end
+
+          private
+
+          def generate_url
+            create_tunnel
+            update_url unless no_update
+            show_app_url
+          end
+
+          def create_tunnel
+            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)
+          end
+
+          def update_url
+            ShopifyCLI::Tasks::UpdateDashboardURLS.call(
+              context,
+              url: project.env.host,
+              callback_urls: %w(/auth/shopify/callback /auth/callback),
+            )
+          end
+
+          def show_app_url
+            return unless 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
+
+          def project
+            @project ||= ShopifyCLI::Project.current
+          end
+        end
+      end
+    end
+  end
+end

package/assets/cli-ruby/lib/shopify_cli/services/app/tunnel/auth_service.rb

@@ -0,0 +1,21 @@
+module ShopifyCLI
+  module Services
+    module App
+      module Tunnel
+        class AuthService < BaseService
+          attr_accessor :context, :token
+
+          def initialize(token:, context:)
+            @context = context
+            @token = token
+            super()
+          end
+
+          def call
+            ShopifyCLI::Tunnel.auth(context, token)
+          end
+        end
+      end
+    end
+  end
+end

package/assets/cli-ruby/lib/shopify_cli/services/app/tunnel/start_service.rb

@@ -0,0 +1,20 @@
+module ShopifyCLI
+  module Services
+    module App
+      module Tunnel
+        class StartService < BaseService
+          attr_accessor :context
+
+          def initialize(context:)
+            @context = context
+            super()
+          end
+
+          def call
+            ShopifyCLI::Tunnel.start(context)
+          end
+        end
+      end
+    end
+  end
+end

package/assets/cli-ruby/lib/shopify_cli/services/app/tunnel/stop_service.rb

@@ -0,0 +1,20 @@
+module ShopifyCLI
+  module Services
+    module App
+      module Tunnel
+        class StopService < BaseService
+          attr_accessor :context
+
+          def initialize(context:)
+            @context = context
+            super()
+          end
+
+          def call
+            ShopifyCLI::Tunnel.stop(context)
+          end
+        end
+      end
+    end
+  end
+end

package/assets/cli-ruby/lib/shopify_cli/services/base_service.rb

@@ -0,0 +1,13 @@
+module ShopifyCLI
+  module Services
+    class BaseService
+      def self.call(*args, **kwargs, &block)
+        new(*args, **kwargs).call(&block)
+      end
+
+      def call
+        raise NotImplementedError
+      end
+    end
+  end
+end

package/assets/cli-ruby/lib/shopify_cli/services/reporting_service.rb

@@ -0,0 +1,16 @@
+module ShopifyCLI
+  module Services
+    class ReportingService < BaseService
+      attr_reader :enable
+
+      def initialize(enable:)
+        @enable = enable
+        super()
+      end
+
+      def call
+        ReportingConfigurationController.enable_reporting(enable)
+      end
+    end
+  end
+end

package/assets/cli-ruby/lib/shopify_cli/services.rb

@@ -0,0 +1,38 @@
+module ShopifyCLI
+  module Services
+    autoload :BaseService, "shopify_cli/services/base_service"
+    autoload :ReportingService, "shopify_cli/services/reporting_service"
+
+    module App
+      module Serve
+        autoload :ServeService, "shopify_cli/services/app/serve/serve_service"
+        autoload :NodeService, "shopify_cli/services/app/serve/node_service"
+        autoload :RailsService, "shopify_cli/services/app/serve/rails_service"
+        autoload :PHPService, "shopify_cli/services/app/serve/php_service"
+      end
+
+      module Create
+        autoload :NodeService, "shopify_cli/services/app/create/node_service"
+        autoload :RailsService, "shopify_cli/services/app/create/rails_service"
+        autoload :PHPService, "shopify_cli/services/app/create/php_service"
+      end
+
+      module Deploy
+        module Heroku
+          autoload :NodeService, "shopify_cli/services/app/deploy/heroku/node_service"
+          autoload :RailsService, "shopify_cli/services/app/deploy/heroku/rails_service"
+          autoload :PHPService, "shopify_cli/services/app/deploy/heroku/php_service"
+        end
+      end
+
+      module Tunnel
+        autoload :StartService, "shopify_cli/services/app/tunnel/start_service"
+        autoload :StopService, "shopify_cli/services/app/tunnel/stop_service"
+        autoload :AuthService, "shopify_cli/services/app/tunnel/auth_service"
+      end
+
+      autoload :ConnectService, "shopify_cli/services/app/connect_service"
+      autoload :OpenService, "shopify_cli/services/app/open_service"
+    end
+  end
+end

package/assets/cli-ruby/lib/shopify_cli/shopifolk.rb

@@ -0,0 +1,81 @@
+module ShopifyCLI
+  ##
+  # ShopifyCLI::Shopifolk contains the logic to determine if the user appears to be a Shopify staff
+  #
+  # The Shopifolk Feature flag will persist between runs so if the flag is enabled or disabled,
+  # it will still be in that same state until the next class invocation.
+  class Shopifolk
+    GCLOUD_CONFIG_FILE = File.expand_path("~/.config/gcloud/configurations/config_default")
+    DEV_PATH = "/opt/dev"
+    SECTION = "core"
+    FEATURE_NAME = "shopifolk"
+
+    class << self
+      ##
+      # will return if the user appears to be a Shopify employee, based on several heuristics
+      #
+      # #### Returns
+      #
+      # * `is_shopifolk` - returns true if the user is a Shopify Employee
+      #
+      # #### Example
+      #
+      #     ShopifyCLI::Shopifolk.check
+      #
+      def check
+        ShopifyCLI::Shopifolk.new.shopifolk?
+      end
+
+      def act_as_shopify_organization
+        DB.set(acting_as_shopify_organization: true)
+      end
+
+      def acting_as_shopify_organization?
+        !!(DB.get(:acting_as_shopify_organization) ||
+        (Project.has_current? && Project.current.config["shopify_organization"]))
+      end
+
+      def reset
+        DB.del(:acting_as_shopify_organization)
+      end
+    end
+
+    ##
+    # will return if the user is a Shopify employee
+    #
+    # #### Returns
+    #
+    # * `is_shopifolk` - returns true if the user has `dev` installed and
+    # a valid google cloud config file with email ending in "@shopify.com"
+    #
+    def shopifolk?
+      return true if Feature.enabled?(FEATURE_NAME)
+
+      if shopifolk_by_gcloud? && shopifolk_by_dev?
+        ShopifyCLI::Feature.enable(FEATURE_NAME)
+        true
+      else
+        ShopifyCLI::Feature.disable(FEATURE_NAME)
+        false
+      end
+    end
+
+    private
+
+    def shopifolk_by_gcloud?
+      ini&.dig("[#{SECTION}]", "account")&.match?(/@shopify.com\z/)
+    end
+
+    def shopifolk_by_dev?
+      File.exist?("#{DEV_PATH}/bin/dev") && File.exist?("#{DEV_PATH}/.shopify-build")
+    end
+
+    def ini
+      @ini ||= if File.exist?(GCLOUD_CONFIG_FILE)
+        CLI::Kit::Ini
+          .new(GCLOUD_CONFIG_FILE, default_section: "[#{SECTION}]", convert_types: false)
+          .tap(&:parse).ini
+      end
+    end
+  end
+end

package/assets/cli-ruby/lib/shopify_cli/task.rb

@@ -0,0 +1,20 @@
+require "shopify_cli"
+
+module ShopifyCLI
+  class Task
+    class << self
+      ruby2_keywords def call(*args)
+        task = new
+        task.call(*args)
+      end
+    end
+
+    private
+
+    def wants_to_run_against_shopify_org?
+      @ctx.puts(@ctx.message("core.tasks.select_org_and_shop.identified_as_shopify"))
+      message = @ctx.message("core.tasks.select_org_and_shop.first_party")
+      CLI::UI::Prompt.confirm(message, default: false)
+    end
+  end
+end

package/assets/cli-ruby/lib/shopify_cli/tasks/confirm_store.rb

@@ -0,0 +1,18 @@
+require "shopify_cli"
+
+module ShopifyCLI
+  module Tasks
+    class ConfirmStore < ShopifyCLI::Task
+      def call(ctx)
+        @ctx = ctx
+        store = ShopifyCLI::AdminAPI.get_shop_or_abort(ctx)
+        if CLI::UI::Prompt.confirm(ctx.message("core.tasks.confirm_store.prompt", store), default: false)
+          ctx.puts(ctx.message("core.tasks.confirm_store.confirmation", store))
+        else
+          ctx.puts(ctx.message("core.tasks.confirm_store.cancelling"))
+          raise AbortSilent
+        end
+      end
+    end
+  end
+end

package/assets/cli-ruby/lib/shopify_cli/tasks/create_api_client.rb

@@ -0,0 +1,40 @@
+require "shopify_cli"
+
+module ShopifyCLI
+  module Tasks
+    class CreateApiClient < ShopifyCLI::Task
+      VALID_APP_TYPES = %w(public custom)
+      DEFAULT_APP_URL = "https://shopify.github.io/shopify-cli/help/start-app/"
+
+      def call(ctx, org_id:, title:, type:)
+        resp = ShopifyCLI::PartnersAPI.query(
+          ctx,
+          "create_app",
+          org: org_id.to_i,
+          title: title,
+          type: type,
+          app_url: DEFAULT_APP_URL,
+          redir: [IdentityAuth::REDIRECT_HOST]
+        )
+
+        unless resp
+          ctx.abort("Error - empty response")
+        end
+
+        errors = resp.dig("errors")
+        if !errors.nil? && errors.any?
+          ctx.abort(errors.map { |err| "#{err["field"]} #{err["message"]}" }.join(", "))
+        end
+
+        user_errors = resp.dig("data", "appCreate", "userErrors")
+        if !user_errors.nil? && user_errors.any?
+          ctx.abort(user_errors.map { |err| "#{err["field"]} #{err["message"]}" }.join(", "))
+        end
+
+        ShopifyCLI::Core::Monorail.metadata[:api_key] = resp.dig("data", "appCreate", "app", "apiKey")
+
+        resp.dig("data", "appCreate", "app")
+      end
+    end
+  end
+end

package/assets/cli-ruby/lib/shopify_cli/tasks/ensure_authenticated.rb

@@ -0,0 +1,19 @@
+require "shopify_cli"
+
+module ShopifyCLI
+  module Tasks
+    class EnsureAuthenticated < ShopifyCLI::Task
+      def call(ctx)
+        return if ShopifyCLI::Environment.acceptance_test?
+        unless ShopifyCLI::IdentityAuth.authenticated?
+          raise ShopifyCLI::Abort,
+            ctx.message("core.identity_auth.login_prompt", ShopifyCLI::TOOL_NAME)
+        end
+        if ShopifyCLI::IdentityAuth.environment_auth_token?
+          ctx.puts(ctx.message("core.identity_auth.token_authentication",
+            ShopifyCLI::Constants::EnvironmentVariables::AUTH_TOKEN))
+        end
+      end
+    end
+  end
+end

package/assets/cli-ruby/lib/shopify_cli/tasks/ensure_dev_store.rb

@@ -0,0 +1,41 @@
+require "shopify_cli"
+
+module ShopifyCLI
+  module Tasks
+    class EnsureDevStore < ShopifyCLI::Task
+      def call(ctx)
+        @ctx = ctx
+        return ctx.abort(ctx.message(
+          "core.tasks.ensure_dev_store.could_not_verify_store", project.env.shop
+        )) if shop.nil?
+        return if shop["transferDisabled"] == true
+        return unless CLI::UI::Prompt.confirm(
+          ctx.message("core.tasks.ensure_dev_store.convert_to_dev_store", project.env.shop)
+        )
+        ShopifyCLI::PartnersAPI.query(ctx, "convert_dev_to_test_store", input: {
+          organizationID: shop["orgID"].to_i,
+          shopId: shop["shopId"],
+        })
+        ctx.puts(ctx.message("core.tasks.ensure_dev_store.transfer_disabled", project.env.shop))
+      end
+
+      private
+
+      def project
+        @project ||= ShopifyCLI::Project.current
+      end
+
+      def shop
+        @shop ||= begin
+          current_domain = project.env.shop
+          ShopifyCLI::PartnersAPI::Organizations.fetch_all(@ctx).map do |org|
+            org["stores"].find do |store|
+              store["orgID"] = org["id"]
+              store["shopDomain"] == current_domain
+            end
+          end.compact.first
+        end
+      end
+    end
+  end
+end