@shopify/cli-kit 3.69.4 → 3.71.0

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

@@ -1,90 +0,0 @@
-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

@@ -1,14 +0,0 @@
-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

@@ -1,20 +0,0 @@
-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

@@ -1,14 +0,0 @@
-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

@@ -1,81 +0,0 @@
-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

@@ -1,57 +0,0 @@
-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

@@ -1,44 +0,0 @@
-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

@@ -1,47 +0,0 @@
-# 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

@@ -1,82 +0,0 @@
-# frozen_string_literal: true
-
-module ShopifyCLI
-  module Theme
-    class DevServer
-      class CdnFonts
-        FONTS_PATH = "/fonts"
-        FONTS_CDN = "https://fonts.shopifycdn.com"
-
-        def initialize(ctx, app, theme:)
-          @ctx = ctx
-          @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)
-          content_type = headers["Content-Type"] || headers["content-type"]
-          if content_type.nil? || content_type == "" || content_type&.start_with?("text/")
-            [status, headers, replace_font_urls(body)]
-          else
-            [status, headers, body]
-          end
-        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)
-          fonts_regex = %r{#{FONTS_CDN}|((http:|https:)?//#{shop}/cdn/fonts)}
-          [body.join.gsub(fonts_regex, FONTS_PATH)]
-        end
-
-        def shop
-          @shop ||= ShopifyCLI::Theme::ThemeAdminAPI.new(@ctx).get_shop_or_abort
-        end
-      end
-    end
-  end
-end

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

@@ -1,79 +0,0 @@
-# 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

@@ -1,9 +0,0 @@
-# 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

@@ -1,98 +0,0 @@
-# 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