shopify-cli 1.12.0 → 2.0.1

data/lib/project_types/theme/ui/sync_progress_bar.rb

@@ -0,0 +1,20 @@
+module Theme
+  module UI
+    class SyncProgressBar
+      def initialize(syncer)
+        @syncer = syncer
+      end
+
+      def progress(method, **args)
+        @syncer.delay_errors!
+        CLI::UI::Progress.progress do |bar|
+          @syncer.public_send(method, **args) do |left, total|
+            bar.tick(set_percent: 1 - left.to_f / total)
+          end
+          bar.tick(set_percent: 1)
+        end
+        @syncer.report_errors!
+      end
+    end
+  end
+end

data/lib/shopify-cli/admin_api.rb

@@ -38,9 +38,15 @@ module ShopifyCli
       #   ShopifyCli::AdminAPI.query(@ctx, 'all_organizations')
       #
       def query(ctx, query_name, shop:, api_version: nil, **variables)
-        authenticated_req(ctx, shop) do
+        CLI::Kit::Util.begin do
           api_client(ctx, api_version, shop).query(query_name, variables: variables)
+        end.retry_after(API::APIRequestUnauthorizedError, retries: 1) do
+          ShopifyCli::IdentityAuth.new(ctx: ctx).reauthenticate
         end
+      rescue API::APIRequestUnauthorizedError
+        ctx.abort(ctx.message("core.api.error.failed_auth"))
+      rescue API::APIRequestForbiddenError
+        ctx.abort(ctx.message("core.api.error.forbidden", ShopifyCli::TOOL_NAME))
       end
 
       ##
@@ -75,49 +81,47 @@ module ShopifyCli
       #                                     path: 'data.json',
       #                                     token: 'password')
       #
-      def rest_request(ctx, shop:, path:, body: nil, method: "GET", api_version: nil, token: nil)
-        ShopifyCli::DB.set(admin_access_token: token) unless token.nil?
-        url = URI::HTTPS.build(host: shop, path: "/admin/api/#{fetch_api_version(ctx, api_version, shop)}/#{path}")
-        resp = api_client(ctx, api_version, shop, path: path).request(url: url.to_s, body: body, method: method)
-        ShopifyCli::DB.set(admin_access_token: nil) unless token.nil?
-        resp
+      def rest_request(ctx, shop:, path:, query: nil, body: nil, method: "GET", api_version: nil, token: nil)
+        CLI::Kit::Util.begin do
+          ShopifyCli::DB.set(shopify_exchange_token: token) unless token.nil?
+          url = URI::HTTPS.build(
+            host: shop,
+            path: "/admin/api/#{fetch_api_version(ctx, api_version, shop)}/#{path}",
+            query: query,
+          )
+          resp = api_client(ctx, api_version, shop, path: path).request(url: url.to_s, body: body, method: method)
+          ShopifyCli::DB.set(shopify_exchange_token: nil) unless token.nil?
+          resp
+        end.retry_after(API::APIRequestUnauthorizedError) do
+          ShopifyCli::IdentityAuth.new(ctx: ctx).reauthenticate
+        end
       end
 
-      private
-
-      def authenticated_req(ctx, shop)
-        yield
-      rescue API::APIRequestUnauthorizedError
-        authenticate(ctx, shop)
-        retry
+      def get_shop_or_abort(ctx)
+        ctx.abort(
+          ctx.message("core.populate.error.no_shop", ShopifyCli::TOOL_NAME)
+        ) unless ShopifyCli::DB.exists?(:shop)
+        ShopifyCli::DB.get(:shop)
       end
 
-      def authenticate(ctx, shop)
-        env = Project.current.env
-        ShopifyCli::OAuth.new(
-          ctx: ctx,
-          service: "admin",
-          client_id: env.api_key,
-          secret: env.secret,
-          scopes: env.scopes,
-          token_path: "/access_token",
-          options: { "grant_options[]" => "per user" },
-        ).authenticate("https://#{shop}/admin/oauth")
+      private
+
+      def authenticate(ctx, _shop)
+        ShopifyCli::IdentityAuth.new(ctx: ctx).authenticate
       end
 
       def api_client(ctx, api_version, shop, path: "graphql.json")
         new(
           ctx: ctx,
-          auth_header: "X-Shopify-Access-Token",
-          token: admin_access_token(ctx, shop),
+          token: access_token(ctx, shop),
           url: "https://#{shop}/admin/api/#{fetch_api_version(ctx, api_version, shop)}/#{path}",
         )
       end
 
-      def admin_access_token(ctx, shop)
-        ShopifyCli::DB.get(:admin_access_token) do
+      def access_token(ctx, shop)
+        ShopifyCli::DB.get(:shopify_exchange_token) do
           authenticate(ctx, shop)
-          ShopifyCli::DB.get(:admin_access_token)
+          ShopifyCli::DB.get(:shopify_exchange_token)
         end
       end
 
@@ -125,14 +129,28 @@ module ShopifyCli
         return api_version unless api_version.nil?
         client = new(
           ctx: ctx,
-          auth_header: "X-Shopify-Access-Token",
-          token: admin_access_token(ctx, shop),
+          token: access_token(ctx, shop),
           url: "https://#{shop}/admin/api/unstable/graphql.json",
         )
-        versions = client.query("api_versions")["data"]["publicApiVersions"]
-        latest = versions.find { |version| version["displayName"].include?("Latest") }
-        latest["handle"]
+        CLI::Kit::Util.begin do
+          versions = client.query("api_versions")["data"]["publicApiVersions"]
+          latest = versions.find { |version| version["displayName"].include?("Latest") }
+          latest["handle"]
+        end.retry_after(API::APIRequestUnauthorizedError, retries: 1) do
+          ShopifyCli::IdentityAuth.new(ctx: ctx).reauthenticate
+        end
+      rescue API::APIRequestUnauthorizedError
+        ctx.abort(ctx.message("core.api.error.failed_auth"))
+      rescue API::APIRequestForbiddenError
+        ctx.abort(ctx.message("core.api.error.forbidden", ShopifyCli::TOOL_NAME))
       end
     end
+
+    def auth_headers(token)
+      {
+        Authorization: "Bearer #{token}",
+        "X-Shopify-Access-Token" => token, # TODO: Remove when we no longer need private apps
+      }
+    end
   end
 end

data/lib/shopify-cli/admin_api/populate_resource_command.rb

@@ -25,12 +25,11 @@ module ShopifyCli
       end
 
       def call(args, _)
-        return unless Project.current
-        Tasks::EnsureEnv.call(@ctx)
         @args = args
         @input = Hash.new
         @count = DEFAULT_COUNT
         @help = false
+        @skip_shop_confirmation = false
         input_options
         resource_options.parse(@args)
 
@@ -41,8 +40,8 @@ module ShopifyCli
           return @ctx.puts(output)
         end
 
-        @shop ||= Project.current.env.shop || get_shop(@ctx)
-
+        ShopifyCli::Tasks::ConfirmStore.call(@ctx) unless @skip_shop_confirmation
+        @shop = AdminAPI.get_shop_or_abort(@ctx)
         if @silent
           spin_group = CLI::UI::SpinGroup.new
           spin_group.add(@ctx.message("core.populate.populating", @count, camel_case_resource_type)) do |spinner|
@@ -89,7 +88,7 @@ module ShopifyCli
 
           opts.on("--silent") { |v| @silent = v }
 
-          opts.on("--shop=", "-s") { |value| @shop = value }
+          opts.on("--skip-shop-confirmation") { |v| @skip_shop_confirmation = v }
         end
       end
 
@@ -130,7 +129,7 @@ module ShopifyCli
           "core.populate.completion_message",
           @count,
           "#{camel_case_resource_type}#{plural}",
-          Project.current.env.shop,
+          @shop,
           camel_case_resource_type,
           admin_url,
           snake_case_resource_type
@@ -138,7 +137,7 @@ module ShopifyCli
       end
 
       def admin_url
-        "https://#{Project.current.env.shop}/admin/"
+        "https://#{@shop}/admin/"
       end
 
       def price
@@ -147,13 +146,6 @@ module ShopifyCli
 
       private
 
-      def get_shop(ctx)
-        res = ShopifyCli::Tasks::SelectOrgAndShop.call(ctx)
-        domain = res[:shop_domain]
-        Project.current.env.update(ctx, :shop, domain)
-        domain
-      end
-
       def camel_case_resource_type
         @camel_case_resource_type ||= self.class.to_s.split("::").last
       end

data/lib/shopify-cli/admin_api/schema.rb

@@ -6,7 +6,7 @@ module ShopifyCli
       class << self
         def get(ctx)
           unless ShopifyCli::DB.exists?(:shopify_admin_schema)
-            shop = Project.current.env.shop || get_shop(ctx)
+            shop = AdminAPI.get_shop_or_abort(ctx)
             schema = AdminAPI.query(ctx, "admin_introspection", shop: shop)
             ShopifyCli::DB.set(shopify_admin_schema: JSON.dump(schema))
           end
@@ -15,15 +15,6 @@ module ShopifyCli
           # available
           self[JSON.parse(ShopifyCli::DB.get(:shopify_admin_schema))]
         end
-
-        private
-
-        def get_shop(ctx)
-          res = ShopifyCli::Tasks::SelectOrgAndShop.call(ctx)
-          domain = res[:shop_domain]
-          Project.current.env.update(ctx, :shop, domain)
-          domain
-        end
       end
 
       def type(name)

data/lib/shopify-cli/api.rb

@@ -9,12 +9,22 @@ module ShopifyCli
     property :auth_header, accepts: String
     property! :url, accepts: String
 
-    class APIRequestError < StandardError; end
+    class APIRequestError < StandardError
+      attr_reader :response
+
+      def initialize(message = nil, response: nil)
+        super(message)
+        @response = response
+      end
+    end
+
     class APIRequestNotFoundError < APIRequestError; end
     class APIRequestClientError < APIRequestError; end
     class APIRequestUnauthorizedError < APIRequestClientError; end
+    class APIRequestForbiddenError < APIRequestClientError; end
     class APIRequestUnexpectedError < APIRequestError; end
     class APIRequestRetriableError < APIRequestError; end
+    class APIRequestTimeoutError < APIRequestRetriableError; end
     class APIRequestServerError < APIRequestRetriableError; end
     class APIRequestThrottledError < APIRequestRetriableError; end
 
@@ -46,26 +56,33 @@ module ShopifyCli
         headers = default_headers.merge(headers)
         response = if method == "POST"
           HttpRequest.post(uri, body, headers)
+        elsif method == "PUT"
+          HttpRequest.put(uri, body, headers)
         elsif method == "GET"
           HttpRequest.get(uri, body, headers)
+        elsif method == "DELETE"
+          HttpRequest.delete(uri, body, headers)
         end
-
         case response.code.to_i
         when 200..399
-          [response.code.to_i, JSON.parse(response.body)]
+          [response.code.to_i, JSON.parse(response.body), response]
         when 401
-          raise APIRequestUnauthorizedError, "#{response.code}\n#{response.body}"
+          raise APIRequestUnauthorizedError.new("#{response.code}\n#{response.body}", response: response)
+        when 403
+          raise APIRequestForbiddenError.new("#{response.code}\n#{response.body}", response: response)
         when 404
-          raise APIRequestNotFoundError, "#{response.code}\n#{response.body}"
+          raise APIRequestNotFoundError.new("#{response.code}\n#{response.body}", response: response)
         when 429
-          raise APIRequestThrottledError, "#{response.code}\n#{response.body}"
+          raise APIRequestThrottledError.new("#{response.code}\n#{response.body}", response: response)
         when 400..499
-          raise APIRequestClientError, "#{response.code}\n#{response.body}"
+          raise APIRequestClientError.new("#{response.code}\n#{response.body}", response: response)
         when 500..599
-          raise APIRequestServerError, "#{response.code}\n#{response.body}"
+          raise APIRequestServerError.new("#{response.code}\n#{response.body}", response: response)
         else
-          raise APIRequestUnexpectedError, "#{response.code}\n#{response.body}"
+          raise APIRequestUnexpectedError.new("#{response.code}\n#{response.body}", response: response)
         end
+      rescue Net::OpenTimeout, Net::ReadTimeout, Net::WriteTimeout, Errno::ETIMEDOUT, Timeout::Error
+        raise APIRequestTimeoutError.new("Timeout")
       end.retry_after(APIRequestRetriableError, retries: 3) do |e|
         sleep(1) if e.is_a?(APIRequestThrottledError)
       end
@@ -87,13 +104,11 @@ module ShopifyCli
 
     private
 
-    def current_sha
-      @current_sha ||= Git.sha(dir: ShopifyCli::ROOT)
-    end
-
     def default_headers
       {
-        "User-Agent" => "Shopify App CLI #{ShopifyCli::VERSION} #{current_sha} | #{ctx.uname}",
+        "User-Agent" => "Shopify CLI; v=#{ShopifyCli::VERSION}",
+        "Sec-CH-UA" => "Shopify CLI; v=#{ShopifyCli::VERSION} sha=#{ShopifyCli.sha}",
+        "Sec-CH-UA-PLATFORM" => ctx.os,
       }.tap do |headers|
         headers["X-Shopify-Cli-Employee"] = "1" if Shopifolk.acting_as_shopify_organization?
       end.merge(auth_headers(token))

data/lib/shopify-cli/command.rb

@@ -42,13 +42,16 @@ module ShopifyCli
         )
       end
 
-      def prerequisite_task(*tasks)
+      def prerequisite_task(*tasks_without_args, **tasks_with_args)
         @prerequisite_tasks ||= []
-        @prerequisite_tasks += tasks
+        @prerequisite_tasks += tasks_without_args.map { |t| PrerequisiteTask.new(t) }
+        @prerequisite_tasks += tasks_with_args.map { |t, args| PrerequisiteTask.new(t, args) }
       end
 
       def run_prerequisites
-        (@prerequisite_tasks || []).each { |task| task_registry[task]&.call(@ctx) }
+        (@prerequisite_tasks || []).each do |task|
+          task_registry[task.name]&.call(@ctx, *task.args)
+        end
       end
 
       def task_registry
@@ -59,6 +62,15 @@ module ShopifyCli
         help = Commands::Help.new(@ctx)
         help.call(cmds, nil)
       end
+
+      class PrerequisiteTask
+        attr_reader :name, :args
+
+        def initialize(name, args = [])
+          @name = name
+          @args = args
+        end
+      end
     end
 
     def initialize(ctx = nil)

data/lib/shopify-cli/commands.rb

@@ -19,11 +19,16 @@ module ShopifyCli
     end
 
     register :Config, "config", "shopify-cli/commands/config", true
-    register :Connect, "connect", "shopify-cli/commands/connect", true
-    register :Create, "create", "shopify-cli/commands/create", true
     register :Help, "help", "shopify-cli/commands/help", true
+    register :Login, "login", "shopify-cli/commands/login", true
     register :Logout, "logout", "shopify-cli/commands/logout", true
+    register :Populate, "populate", "shopify-cli/commands/populate", true
+    register :Store, "store", "shopify-cli/commands/store", true
+    register :Switch, "switch", "shopify-cli/commands/switch", true
     register :System, "system", "shopify-cli/commands/system", true
     register :Version, "version", "shopify-cli/commands/version", true
+    register :Whoami, "whoami", "shopify-cli/commands/whoami", true
+
+    autoload :Connect, "shopify-cli/commands/connect"
   end
 end

data/lib/shopify-cli/commands/help.rb

@@ -23,17 +23,9 @@ module ShopifyCli
         preamble = @ctx.message("core.help.preamble", ShopifyCli::TOOL_NAME)
         @ctx.puts(preamble)
 
-        core_commands.each do |name, klass|
-          next if name == "help"
-          @ctx.puts("{{command:#{name}}}: #{klass.help}\n")
-        end
-
-        return unless inside_supported_project?
+        available_commands = resolved_commands.select { |_name, c| !c.hidden? }
 
-        @ctx.puts("{{bold:Project: #{Project.project_name} (#{project_type_name})}}")
-        @ctx.puts("{{bold:Available commands for #{project_type_name} projects:}}\n\n")
-
-        local_commands.each do |name, klass|
+        available_commands.each do |name, klass|
           next if name == "help"
           @ctx.puts("{{command:#{name}}}: #{klass.help}\n")
         end
@@ -41,21 +33,6 @@ module ShopifyCli
 
       private
 
-      def project_type_name
-        ProjectType.load_type(Project.current_project_type).project_name
-      end
-
-      def core_commands
-        resolved_commands
-          .select { |_name, c| !c.hidden? }
-          .select { |name, _c| Commands.core_command?(name) }
-      end
-
-      def local_commands
-        resolved_commands
-          .reject { |name, _c| Commands.core_command?(name) }
-      end
-
       def display_help(klass)
         output = klass.help
         if klass.respond_to?(:extended_help)
@@ -70,10 +47,6 @@ module ShopifyCli
           .resolved_commands
           .sort
       end
-
-      def inside_supported_project?
-        Project.current_project_type && ProjectType.load_type(Project.current_project_type)
-      end
     end
   end
 end

data/lib/shopify-cli/commands/login.rb

@@ -0,0 +1,95 @@
+require "shopify_cli"
+
+module ShopifyCli
+  module Commands
+    class Login < ShopifyCli::Command
+      PROTOCOL_REGEX = /^https?\:\/\//
+      PERMANENT_DOMAIN_SUFFIX = /\.myshopify\.(com|io)$/
+
+      options do |parser, flags|
+        parser.on("--store=STORE") { |url| flags[:shop] = url }
+        # backwards compatibility allow 'shop' for now
+        parser.on("--shop=SHOP") { |url| flags[:shop] = url }
+        parser.on("--password=PASSWORD") { |password| flags[:password] = password }
+      end
+
+      def call(*)
+        shop = (options.flags[:shop] || @ctx.getenv("SHOPIFY_SHOP" || nil))
+        ShopifyCli::DB.set(shop: self.class.validate_shop(shop)) unless shop.nil?
+
+        if shop.nil? && Shopifolk.check
+          Shopifolk.reset
+          @ctx.puts(@ctx.message("core.tasks.select_org_and_shop.identified_as_shopify"))
+          message = @ctx.message("core.tasks.select_org_and_shop.first_party")
+          if CLI::UI::Prompt.confirm(message, default: false)
+            Shopifolk.act_as_shopify_organization
+          end
+        end
+
+        # As password auth will soon be deprecated, we enable only in CI
+        if @ctx.ci? && (password = options.flags[:password] || @ctx.getenv("SHOPIFY_PASSWORD"))
+          ShopifyCli::DB.set(shopify_exchange_token: password)
+        else
+          IdentityAuth.new(ctx: @ctx).authenticate
+          org = select_organization
+          ShopifyCli::DB.set(organization_id: org["id"].to_i) unless org.nil?
+          Whoami.call([], "whoami")
+        end
+      end
+
+      def self.help
+        ShopifyCli::Context.message("core.login.help", ShopifyCli::TOOL_NAME)
+      end
+
+      def self.validate_shop(shop)
+        permanent_domain = shop_to_permanent_domain(shop)
+        @ctx.abort(@ctx.message("core.login.invalid_shop", shop)) unless permanent_domain
+        permanent_domain
+      end
+
+      def self.shop_to_permanent_domain(shop)
+        url = if PROTOCOL_REGEX =~ shop
+          shop
+        elsif shop.include?(".")
+          "https://#{shop}"
+        else
+          "https://#{shop}.myshopify.com"
+        end
+
+        # Make a request to see if it exists or if we get redirected to the permanent domain one
+        uri = URI.parse(url)
+        Net::HTTP.start(uri.host, use_ssl: true) do |http|
+          response = http.request_head("/admin")
+          case response
+          when Net::HTTPSuccess, Net::HTTPSeeOther
+            uri.host
+          when Net::HTTPFound
+            domain = URI.parse(response["location"]).host
+            if PERMANENT_DOMAIN_SUFFIX =~ domain
+              domain
+            end
+          end
+        end
+      end
+
+      private
+
+      def select_organization
+        organizations = ShopifyCli::PartnersAPI::Organizations.fetch_all(@ctx)
+
+        if organizations.count == 0
+          nil
+        elsif organizations.count == 1
+          organizations.first
+        else
+          org_id = CLI::UI::Prompt.ask(@ctx.message("core.tasks.select_org_and_shop.organization_select")) do |handler|
+            organizations.each do |o|
+              handler.option(@ctx.message("core.partners_api.org_name_and_id", o["businessName"], o["id"])) { o["id"] }
+            end
+          end
+          organizations.find { |o| o["id"] == org_id }
+        end
+      end
+    end
+  end
+end