shopify-cli 2.6.5 → 2.7.2

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, 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}/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

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

@@ -0,0 +1,48 @@
+module ShopifyCLI
+  module Services
+    module App
+      module Serve
+        class RailsService < 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/shopify/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
+              env = ShopifyCLI::Project.current.env.to_h
+              env.delete("HOST")
+              env["PORT"] = port.to_s
+              env["GEM_PATH"] = Rails::Gem.gem_path(context)
+              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

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

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

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

data/lib/shopify_cli/services.rb

@@ -2,5 +2,36 @@ module ShopifyCLI
   module Services
     autoload :BaseService, "shopify_cli/services/base_service"
     autoload :ReportingService, "shopify_cli/services/reporting_service"
+
+    module App
+      module Serve
+        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

data/lib/shopify_cli/tasks/ensure_authenticated.rb

@@ -4,9 +4,15 @@ module ShopifyCLI
   module Tasks
     class EnsureAuthenticated < ShopifyCLI::Task
       def call(ctx)
-        ctx.abort(
-          ctx.message("core.identity_auth.login_prompt", ShopifyCLI::TOOL_NAME)
-        ) unless ShopifyCLI::IdentityAuth::IDENTITY_ACCESS_TOKENS.all? { |key| ShopifyCLI::DB.exists?(key) }
+        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

data/lib/shopify_cli/theme/dev_server/local_assets.rb

@@ -4,7 +4,7 @@ module ShopifyCLI
   module Theme
     module DevServer
       class LocalAssets
-        ASSET_REGEX = %r{//cdn.shopify.com/s/.*?/(assets/.+\.(?:css|js))}
+        ASSET_REGEX = %r{//cdn\.shopify\.com/s/.+?/(assets/.+?\.(?:css|js))}
 
         class FileBody
           def initialize(path)

data/lib/shopify_cli/theme/dev_server.rb

@@ -17,10 +17,14 @@ require "pathname"
 module ShopifyCLI
   module Theme
     module DevServer
+      # Errors
+      Error = Class.new(StandardError)
+      AddressBindingError = Class.new(Error)
+
       class << self
         attr_accessor :ctx
 
-        def start(ctx, root, port: 9292, poll: false)
+        def start(ctx, root, host: "127.0.0.1", port: 9292, poll: false)
           @ctx = ctx
           theme = DevelopmentTheme.new(ctx, root: root)
           ignore_filter = IgnoreFilter.from_path(root)
@@ -32,6 +36,7 @@ module ShopifyCLI
           @app = LocalAssets.new(ctx, @app, theme: theme)
           @app = HotReload.new(ctx, @app, theme: theme, watcher: watcher, ignore_filter: ignore_filter)
           stopped = false
+          address = "http://#{host}:#{port}"
 
           theme.ensure_exists!
 
@@ -40,8 +45,8 @@ module ShopifyCLI
             stop
           end
 
-          CLI::UI::Frame.open(@ctx.message("theme.serve.serve")) do
-            ctx.print_task("Syncing theme ##{theme.id} on #{theme.shop}")
+          CLI::UI::Frame.open(@ctx.message("theme.serve.viewing_theme")) do
+            ctx.print_task(ctx.message("theme.serve.syncing_theme", theme.id, theme.shop))
             @syncer.start_threads
             if block_given?
               yield @syncer
@@ -51,18 +56,9 @@ module ShopifyCLI
 
             return if stopped
 
-            ctx.puts("")
-            ctx.puts("Serving #{theme.root}")
-            ctx.puts("")
-            ctx.open_url!("http://127.0.0.1:#{port}")
-            ctx.puts("")
-            ctx.puts("Customize this theme in the Online Store Editor:")
-            ctx.puts("{{green:#{theme.editor_url}}}")
-            ctx.puts("")
-            ctx.puts("Share this theme preview:")
-            ctx.puts("{{green:#{theme.preview_url}}}")
-            ctx.puts("")
-            ctx.puts("(Use Ctrl-C to stop)")
+            ctx.puts(ctx.message("theme.serve.serving", theme.root))
+            ctx.open_url!(address)
+            ctx.puts(ctx.message("theme.serve.customize_or_preview", theme.editor_url, theme.preview_url))
           end
 
           logger = if ctx.debug?
@@ -74,6 +70,7 @@ module ShopifyCLI
           watcher.start
           WebServer.run(
             @app,
+            BindAddress: host,
             Port: port,
             Logger: logger,
             AccessLog: [],
@@ -82,8 +79,11 @@ module ShopifyCLI
 
         rescue ShopifyCLI::API::APIRequestForbiddenError,
                ShopifyCLI::API::APIRequestUnauthorizedError
-          @ctx.abort("You are not authorized to edit themes on #{theme.shop}.\n" \
-                     "Make sure you are a user of that store, and allowed to edit themes.")
+          raise ShopifyCLI::Abort, @ctx.message("theme.serve.ensure_user", theme.shop)
+        rescue Errno::EADDRINUSE
+          abort_address_already_in_use(address)
+        rescue Errno::EADDRNOTAVAIL
+          raise AddressBindingError, "Error binding to the address #{host}."
         end
 
         def stop
@@ -92,6 +92,24 @@ module ShopifyCLI
           @syncer.shutdown
           WebServer.shutdown
         end
+
+        private
+
+        def abort_address_already_in_use(address)
+          open_frame(@ctx.message("theme.serve.already_in_use_error"), color: :red) do
+            @ctx.puts(@ctx.message("theme.serve.address_already_in_use", address))
+          end
+
+          open_frame(@ctx.message("theme.serve.try_this"), color: :green) do
+            @ctx.puts(@ctx.message("theme.serve.try_port_option"))
+          end
+
+          raise ShopifyCLI::AbortSilent
+        end
+
+        def open_frame(title, color:, &block)
+          CLI::UI::Frame.open(title, color: CLI::UI.resolve_color(color), timing: false, &block)
+        end
       end
     end
   end

data/lib/shopify_cli/theme/syncer/error_reporter.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module ShopifyCLI
+  module Theme
+    class Syncer
+      ##
+      # ShopifyCLI::Theme::Syncer::ErrorReporter allows delaying log of errors,
+      # mainly to not break the progress bar.
+      #
+      class ErrorReporter
+        attr_reader :ctx, :delayed_errors
+
+        def initialize(ctx)
+          @ctx = ctx
+          @has_any_error = false
+          @delay_errors = false
+          @delayed_errors = []
+        end
+
+        def disable!
+          @delay_errors = true
+        end
+
+        def enable!
+          @delay_errors = false
+          @delayed_errors.each { |error| report(error) }
+          @delayed_errors.clear
+        end
+
+        def report(error_message)
+          if @delay_errors
+            @delayed_errors << error_message
+          else
+            @has_any_error = true
+            @ctx.error(error_message)
+          end
+        end
+
+        def has_any_error?
+          @has_any_error
+        end
+      end
+    end
+  end
+end

data/lib/shopify_cli/theme/syncer/operation.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module ShopifyCLI
+  module Theme
+    class Syncer
+      class Operation
+        attr_accessor :method, :file
+
+        COLOR_BY_STATUS = {
+          error: :red,
+          synced: :green,
+          fixed: :cyan,
+        }
+
+        def initialize(ctx, method, file)
+          @ctx = ctx
+          @method = method
+          @file = file
+        end
+
+        def to_s
+          "#{method} #{file_path}"
+        end
+
+        def as_error_message
+          as_message_with(status: :error)
+        end
+
+        def as_synced_message
+          as_message_with(status: :synced)
+        end
+
+        def as_fix_message
+          as_message_with(status: :fixed)
+        end
+
+        def file_path
+          file&.relative_path.to_s
+        end
+
+        private
+
+        def as_message_with(status:)
+          status_color = COLOR_BY_STATUS[status]
+          status_text = @ctx.message("theme.serve.operation.status.#{status}").ljust(6)
+
+          "#{timestamp} {{#{status_color}:#{status_text}}} {{>}} {{blue:#{self}}}"
+        end
+
+        def timestamp
+          Time.now.strftime("%T")
+        end
+      end
+    end
+  end
+end

data/lib/shopify_cli/theme/syncer/standard_reporter.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module ShopifyCLI
+  module Theme
+    class Syncer
+      ##
+      # ShopifyCLI::Theme::Syncer::StdReporter allows disabling/enabling
+      # messages reported in the standard output (ShopifyCLI::Context#puts).
+      #
+      class StandardReporter
+        attr_reader :ctx
+
+        def initialize(ctx)
+          @enabled = true
+          @ctx = ctx
+        end
+
+        def disable!
+          @enabled = false
+        end
+
+        def enable!
+          @enabled = true
+        end
+
+        def report(message)
+          ctx.puts(message) if @enabled
+        end
+      end
+    end
+  end
+end