@shopify/cli-kit 3.39.0 → 3.40.1

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

@@ -0,0 +1,90 @@
+require "shopify_cli"
+
+module ShopifyCLI
+  module Tasks
+    class EnsureEnv < ShopifyCLI::Task
+      def call(ctx, regenerate: false, required: [:api_key, :secret])
+        @ctx = ctx
+        env_data =
+          begin
+            Resources::EnvFile.parse_external_env
+          rescue Errno::ENOENT
+            {}
+          end
+
+        return {} if !regenerate && required.all? { |property| env_data[property] }
+
+        org = fetch_org
+        write_env(env_data, org)
+        org
+      end
+
+      private
+
+      def fetch_org
+        if Shopifolk.check && wants_to_run_against_shopify_org?
+          Shopifolk.act_as_shopify_organization
+        end
+        orgs = PartnersAPI::Organizations.fetch_all_with_apps(@ctx)
+        org_id = if orgs.count == 1
+          orgs.first["id"]
+        else
+          CLI::UI::Prompt.ask(@ctx.message("core.tasks.ensure_env.organization_select")) do |handler|
+            orgs.each do |org|
+              handler.option(
+                @ctx.message("core.partners_api.org_name_and_id", org["businessName"], org["id"])
+              ) { org["id"] }
+            end
+          end
+        end
+        orgs.find { |o| o["id"] == org_id }
+      end
+
+      def get_app(org_id, apps)
+        if apps.count == 1
+          apps.first
+        elsif apps.count == 0
+          @ctx.puts(@ctx.message("core.tasks.ensure_env.no_apps"))
+          title = CLI::UI::Prompt.ask(@ctx.message("core.tasks.ensure_env.app_name"))
+          type = CLI::UI::Prompt.ask(@ctx.message("core.tasks.ensure_env.app_type.select")) do |handler|
+            handler.option(@ctx.message("core.tasks.ensure_env.app_type.select_public")) { "public" }
+            handler.option(@ctx.message("core.tasks.ensure_env.app_type.select_custom")) { "custom" }
+          end
+          ShopifyCLI::Tasks::CreateApiClient.call(@ctx, org_id: org_id, title: title, type: type)
+        else
+          CLI::UI::Prompt.ask(@ctx.message("core.tasks.ensure_env.app_select")) do |handler|
+            apps.each { |app| handler.option(app["title"]) { app } }
+          end
+        end
+      end
+
+      def get_shop(shops, id)
+        if shops.count == 1
+          shop = shops.first["shopDomain"]
+        elsif shops.count == 0
+          @ctx.puts(@ctx.message("core.tasks.ensure_env.no_development_stores", id))
+        else
+          shop = CLI::UI::Prompt.ask(@ctx.message("core.tasks.ensure_env.development_store_select")) do |handler|
+            shops.each { |s| handler.option(s["shopName"]) { s["shopDomain"] } }
+          end
+        end
+        shop
+      end
+
+      def write_env(env_data, org)
+        id = org["id"]
+        app = get_app(id, org["apps"])
+
+        env_data[:shop] = get_shop(org["stores"], id)
+        env_data[:api_key] = app["apiKey"]
+        env_data[:secret] = app["apiSecretKeys"].first["secret"]
+        env_data[:scopes] = "write_products,write_customers,write_draft_orders" if env_data[:scopes].nil?
+        env_data[:extra] = {} if env_data[:extra].nil?
+
+        Resources::EnvFile.new(
+          env_data
+        ).write(@ctx)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,14 @@
+require "shopify_cli"
+
+module ShopifyCLI
+  module Tasks
+    class EnsureGitDependency < ShopifyCLI::Task
+      def call(ctx)
+        return if ShopifyCLI::Environment.acceptance_test?
+        unless ShopifyCLI::Git.exists?(ctx)
+          raise ShopifyCLI::Abort, ctx.message("core.git.error.nonexistent")
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,20 @@
+module ShopifyCLI
+  module Tasks
+    class EnsureLoopbackURL < ShopifyCLI::Task
+      def call(ctx)
+        @ctx = ctx
+        api_key = Project.current.env.api_key
+        result = ShopifyCLI::PartnersAPI.query(ctx, "get_app_urls", apiKey: api_key)
+        loopback = IdentityAuth::REDIRECT_HOST
+        app = result["data"]["app"]
+        urls = app["redirectUrlWhitelist"]
+        if urls.grep(/#{loopback}/).empty?
+          with_loopback = urls.push(loopback)
+          ShopifyCLI::PartnersAPI.query(@ctx, "update_dashboard_urls", input: {
+            redirectUrlWhitelist: with_loopback, apiKey: api_key
+          })
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,14 @@
+require "shopify_cli"
+
+module ShopifyCLI
+  module Tasks
+    class EnsureProjectType < ShopifyCLI::Task
+      def call(ctx, project_type)
+        if project_type.to_sym == ShopifyCLI::Project.current_project_type || Environment.run_as_subprocess?
+          return true
+        end
+        ctx.abort(ctx.message("core.tasks.ensure_project_type.wrong_project_type", project_type))
+      end
+    end
+  end
+end

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

@@ -0,0 +1,81 @@
+require "shopify_cli"
+
+module ShopifyCLI
+  module Tasks
+    class SelectOrgAndShop < ShopifyCLI::Task
+      attr_reader :ctx
+
+      def call(ctx, organization_id: nil, shop_domain: nil)
+        @ctx = ctx
+        return response(organization_id.to_i, shop_domain) unless organization_id.nil? || shop_domain.nil?
+        org = get_organization(organization_id)
+        unless Shopifolk.acting_as_shopify_organization?
+          shop_domain ||= get_shop_domain(org)
+        end
+        ShopifyCLI::Core::Monorail.metadata[:organization_id] = org["id"].to_i
+        response(org["id"].to_i, shop_domain)
+      end
+
+      private
+
+      def response(organization_id, shop_domain)
+        result = { organization_id: organization_id }
+        result[:shop_domain] = shop_domain if shop_domain
+        result
+      end
+
+      def organizations
+        @organizations ||= ShopifyCLI::PartnersAPI::Organizations.fetch_all(ctx)
+      end
+
+      def get_organization(organization_id)
+        @organization ||= if !organization_id.nil?
+          org = ShopifyCLI::PartnersAPI::Organizations.fetch(ctx, id: organization_id)
+          if org.nil?
+            ctx.puts(ctx.message("core.tasks.select_org_and_shop.authentication_issue", ShopifyCLI::TOOL_NAME))
+            ctx.abort(ctx.message("core.tasks.select_org_and_shop.error.organization_not_found"))
+          end
+          org
+        elsif organizations.count == 0
+          if Shopifolk.acting_as_shopify_organization?
+            ctx.abort(ctx.message("core.tasks.select_org_and_shop.error.shopifolk_notice", ShopifyCLI::TOOL_NAME))
+          else
+            ctx.abort(ctx.message("core.tasks.select_org_and_shop.error.no_organizations"))
+          end
+        elsif organizations.count == 1
+          org = organizations.first
+          ctx.puts(ctx.message("core.tasks.select_org_and_shop.organization", org["businessName"], org["id"]))
+          org
+        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
+
+      def get_shop_domain(organization)
+        valid_stores = organization["stores"].select do |store|
+          store["transferDisabled"] == true || store["convertableToPartnerTest"] == true
+        end
+
+        if valid_stores.count == 0
+          ctx.puts(ctx.message("core.tasks.select_org_and_shop.error.no_development_stores"))
+          ctx.puts(ctx.message("core.tasks.select_org_and_shop.create_store", organization["id"]))
+          ctx.puts(ctx.message("core.tasks.select_org_and_shop.authentication_issue", ShopifyCLI::TOOL_NAME))
+        elsif valid_stores.count == 1
+          domain = valid_stores.first["shopDomain"]
+          ctx.puts(ctx.message("core.tasks.select_org_and_shop.development_store", domain))
+          domain
+        else
+          CLI::UI::Prompt.ask(
+            ctx.message("core.tasks.select_org_and_shop.development_store_select"),
+            options: valid_stores.map { |s| s["shopDomain"] }
+          )
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,57 @@
+require "set"
+
+module ShopifyCLI
+  module Tasks
+    class UpdateDashboardURLS < ShopifyCLI::Task
+      NGROK_REGEX = /https:\/\/([a-z0-9\-]+\.ngrok\.io)(.*)/
+
+      def call(ctx, url:, callback_urls:)
+        @ctx = ctx
+        project = ShopifyCLI::Project.current
+        api_key = project.env.api_key
+        result = ShopifyCLI::PartnersAPI.query(ctx, "get_app_urls", apiKey: api_key)
+        app = result["data"]["app"]
+
+        constructed_urls = construct_redirect_urls(app["redirectUrlWhitelist"], url, callback_urls)
+
+        return if already_updated(app, constructed_urls, url)
+
+        ShopifyCLI::PartnersAPI.query(@ctx, "update_dashboard_urls", input: {
+          applicationUrl: url,
+          redirectUrlWhitelist: constructed_urls,
+          apiKey: api_key,
+        })
+
+        @ctx.puts(@ctx.message("core.tasks.update_dashboard_urls.updated"))
+      rescue
+        @ctx.puts(@ctx.message("core.tasks.update_dashboard_urls.update_error", ShopifyCLI::TOOL_NAME))
+        raise
+      end
+
+      def construct_redirect_urls(urls, new_url, callback_urls)
+        new_urls = urls.map do |url|
+          if (match = url.match(NGROK_REGEX))
+            "#{new_url}#{match[2]}"
+          else
+            url
+          end
+        end
+        callback_urls.each do |callback_url|
+          if new_urls.grep(/#{new_url}#{callback_url}/).empty?
+            new_urls.push("#{new_url}#{callback_url}")
+          end
+        end
+        new_urls.uniq
+      end
+
+      private
+
+      def already_updated(app, new_redirect_urls, new_url)
+        current_url = app["applicationUrl"]
+        current_redirect_urls = app["redirectUrlWhitelist"]
+        current_url.match(new_url) &&
+          Set.new(current_redirect_urls) == Set.new(new_redirect_urls)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,44 @@
+require "shopify_cli"
+
+module ShopifyCLI
+  module Tasks
+    class TaskRegistry
+      def initialize
+        @tasks = {}
+      end
+
+      def add(const, name)
+        @tasks[name] = const
+      end
+
+      def [](name)
+        class_or_proc = @tasks[name]
+        if class_or_proc.is_a?(Class)
+          class_or_proc
+        elsif class_or_proc.respond_to?(:call)
+          class_or_proc.call
+        else
+          class_or_proc
+        end
+      end
+    end
+
+    Registry = TaskRegistry.new
+
+    def self.register(task, name, path = nil)
+      autoload(task, path) if path
+      Registry.add(-> () { const_get(task) }, name)
+    end
+
+    register :ConfirmStore, :confirm_store, "shopify_cli/tasks/confirm_store"
+    register :CreateApiClient, :create_api_client, "shopify_cli/tasks/create_api_client"
+    register :EnsureAuthenticated, :ensure_authenticated, "shopify_cli/tasks/ensure_authenticated"
+    register :EnsureEnv, :ensure_env, "shopify_cli/tasks/ensure_env"
+    register :EnsureGitDependency, :ensure_git_dependency, "shopify_cli/tasks/ensure_git_dependency"
+    register :EnsureLoopbackURL, :ensure_loopback_url, "shopify_cli/tasks/ensure_loopback_url"
+    register :EnsureProjectType, :ensure_project_type, "shopify_cli/tasks/ensure_project_type"
+    register :EnsureDevStore, :ensure_dev_store, "shopify_cli/tasks/ensure_dev_store"
+    register :SelectOrgAndShop, :select_org_and_shop, "shopify_cli/tasks/select_org_and_shop"
+    register :UpdateDashboardURLS, :update_dashboard_urls, "shopify_cli/tasks/update_dashboard_urls"
+  end
+end

package/assets/cli-ruby/lib/shopify_cli/theme/backoff_helper.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module ShopifyCLI
+  module Theme
+    module BackoffHelper
+      def initialize_backoff_helper!(margin: 2, backoff_delay: 2)
+        @margin = margin
+        @backoff_delay = backoff_delay
+        @backoff_mutex = Mutex.new
+      end
+
+      def backoff_if_near_limit!(response)
+        # Check if the API told us we're near the rate limit
+        return if backingoff? || !response
+
+        limit = response.fetch("x-shopify-shop-api-call-limit", "0/999")
+        used, total = limit.split("/").map(&:to_i)
+
+        backoff! if used > total - @margin
+      end
+
+      def wait_for_backoff!
+        # Sleeping in the mutex in another thread. Wait for unlock
+        backoff_mutex.synchronize {} if backingoff?
+      end
+
+      def backoff!
+        ctx.debug("Near API call limit, waiting #{@backoff_delay} seconds")
+        backoff_mutex.synchronize { wait(@backoff_delay) }
+      end
+
+      def backingoff?
+        backoff_mutex.locked?
+      end
+
+      def backoff_mutex
+        @backoff_mutex || raise("Backoff helper must be initialized")
+      end
+
+      private
+
+      def wait(seconds)
+        sleep(seconds)
+      end
+    end
+  end
+end

package/assets/cli-ruby/lib/shopify_cli/theme/dev_server/cdn_fonts.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+module ShopifyCLI
+  module Theme
+    class DevServer
+      class CdnFonts
+        FONTS_PATH = "/fonts"
+        FONTS_CDN = "https://fonts.shopifycdn.com"
+        FONTS_REGEX = %r{#{FONTS_CDN}}
+
+        def initialize(app, theme:)
+          @app = app
+          @theme = theme
+        end
+
+        def call(env)
+          path = env["PATH_INFO"]
+
+          # Serve from fonts CDN
+          return serve_font(env) if path.start_with?(FONTS_PATH)
+
+          # Proxy the request, and replace the URLs in the response
+          status, headers, body = @app.call(env)
+          body = replace_font_urls(body)
+          [status, headers, body]
+        end
+
+        private
+
+        def serve_font(env)
+          parameters = %w(PATH_INFO QUERY_STRING REQUEST_METHOD rack.input)
+          path, query, method, body_stream = *env.slice(*parameters).values
+
+          uri = fonts_cdn_uri(path, query)
+
+          response = Net::HTTP.start(uri.host, 443, use_ssl: true) do |http|
+            req_class = Net::HTTP.const_get(method.capitalize)
+            req = req_class.new(uri)
+            req.initialize_http_header(fonts_cdn_headers)
+            req.body_stream = body_stream
+            http.request(req)
+          end
+
+          [
+            response.code.to_s,
+            {
+              "Content-Type" => response.content_type,
+              "Content-Length" => response.content_length.to_s,
+            },
+            [response.body],
+          ]
+        end
+
+        def fonts_cdn_headers
+          {
+            "Referer" => "https://#{@theme.shop}",
+            "Transfer-Encoding" => "chunked",
+          }
+        end
+
+        def fonts_cdn_uri(path, query)
+          uri = URI.join("#{FONTS_CDN}/", path.gsub(%r{^#{FONTS_PATH}\/}, ""))
+          uri.query = query.split("&").last
+          uri
+        end
+
+        def replace_font_urls(body)
+          [body.join.gsub(FONTS_REGEX, FONTS_PATH)]
+        end
+      end
+    end
+  end
+end

package/assets/cli-ruby/lib/shopify_cli/theme/dev_server/certificate_manager.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+require "openssl"
+
+module ShopifyCLI
+  module Theme
+    class DevServer
+      class CertificateManager
+        attr_reader :ctx, :domain_name, :certificate, :private_key
+
+        ISSUER_EXTENSIONS = [
+          ["subjectKeyIdentifier", "hash", false],
+          ["authorityKeyIdentifier", "keyid:always", false],
+        ]
+
+        def initialize(ctx, domain_name)
+          @ctx = ctx
+          @domain_name = domain_name
+        end
+
+        def find_or_create_certificates!
+          @private_key = if (private_key_pem = ShopifyCLI::DB.get(:ssl_private_key))
+            OpenSSL::PKey::RSA.new(private_key_pem)
+          else
+            OpenSSL::PKey::RSA.new(2048)
+          end
+
+          @certificate = if (certificate_pem = ShopifyCLI::DB.get(:ssl_certificate))
+            OpenSSL::X509::Certificate.new(certificate_pem)
+          else
+            x509_certificate = build_x509_certificate
+
+            sign_certificate!(x509_certificate)
+
+            x509_certificate
+          end
+
+          ShopifyCLI::DB.set(ssl_certificate: certificate.to_pem)
+          ShopifyCLI::DB.set(ssl_private_key: private_key.to_pem)
+        end
+
+        private
+
+        def build_x509_certificate
+          certificate = OpenSSL::X509::Certificate.new
+
+          certificate.public_key = private_key.public_key
+          certificate.subject = subject
+          certificate.version = 2
+          certificate.serial = 0x0
+
+          certificate.not_before = Time.now.utc
+          certificate.not_after = Time.now.utc + 365 * 24 * 60 * 60
+
+          certificate
+        end
+
+        def sign_certificate!(certificate)
+          ef = OpenSSL::X509::ExtensionFactory.new
+
+          ef.subject_certificate = certificate
+          ef.issuer_certificate = certificate
+
+          ISSUER_EXTENSIONS.each do |args|
+            certificate.add_extension(ef.create_extension(*args))
+          end
+
+          certificate.add_extension(ef.create_extension("subjectAltName", "DNS:#{@domain_name}", false))
+
+          certificate.sign(private_key, OpenSSL::Digest.new("SHA256"))
+        end
+
+        def subject
+          OpenSSL::X509::Name.parse("/CN=#{@domain_name}/")
+        end
+      end
+    end
+  end
+end

package/assets/cli-ruby/lib/shopify_cli/theme/dev_server/errors.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+module ShopifyCLI
+  module Theme
+    class DevServer
+      # Errors
+      class Error < StandardError; end
+    end
+  end
+end

package/assets/cli-ruby/lib/shopify_cli/theme/dev_server/header_hash.rb

@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+
+module ShopifyCLI
+  module Theme
+    class DevServer
+      # Based on Rack::HeaderHash
+      class HeaderHash < Hash
+        def self.[](headers)
+          if headers.is_a?(HeaderHash) && !headers.frozen?
+            headers
+          else
+            new(headers)
+          end
+        end
+
+        def initialize(hash = {})
+          super()
+          @names = {}
+          hash.each { |k, v| self[k] = v }
+        end
+
+        # on dup/clone, we need to duplicate @names hash
+        def initialize_copy(other)
+          super
+          @names = other.names.dup
+        end
+
+        # on clear, we need to clear @names hash
+        def clear
+          super
+          @names.clear
+        end
+
+        def each
+          super do |k, v|
+            yield(k, v.respond_to?(:to_ary) ? v.to_ary.join("\n") : v)
+          end
+        end
+
+        def to_hash
+          hash = {}
+          each { |k, v| hash[k] = v }
+          hash
+        end
+
+        def [](k)
+          super(k) || super(@names[k.downcase])
+        end
+
+        def fetch(k, default = nil)
+          self[k] || super(@names[k.downcase], default)
+        end
+
+        def []=(k, v)
+          canonical = k.downcase.freeze
+          # .delete is expensive, don't invoke it unless necessary
+          delete(k) if @names[canonical] && @names[canonical] != k
+          @names[canonical] = k
+          super(k, v)
+        end
+
+        def delete(k)
+          canonical = k.downcase
+          result = super(@names.delete(canonical))
+          result
+        end
+
+        def include?(k)
+          super || @names.include?(k.downcase)
+        end
+
+        alias_method :has_key?, :include?
+        alias_method :member?, :include?
+        alias_method :key?, :include?
+
+        def merge!(other)
+          other.each { |k, v| self[k] = v }
+          self
+        end
+
+        def merge(other)
+          hash = dup
+          hash.merge!(other)
+        end
+
+        def replace(other)
+          clear
+          other.each { |k, v| self[k] = v }
+          self
+        end
+
+        protected
+
+        attr_reader :names
+      end
+    end
+  end
+end