@shopify/cli-kit 3.69.4 → 3.70.0

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

@@ -1,75 +0,0 @@
-# frozen_string_literal: true
-
-module ShopifyCLI
-  module Theme
-    class DevServer
-      class HotReload
-        def initialize(ctx, app, broadcast_hooks: [], script_injector: nil, watcher:, mode:)
-          @ctx = ctx
-          @app = app
-          @mode = mode
-          @broadcast_hooks = broadcast_hooks
-          @script_injector = script_injector
-          @streams = SSE::Streams.new
-          @watcher = watcher
-          @watcher.add_observer(self, :notify_streams_of_file_change)
-        end
-
-        def call(env)
-          path = env["PATH_INFO"]
-          if path == "/hot-reload"
-            create_stream
-          else
-            status, headers, body = @app.call(env)
-
-            if request_is_html?(headers) && leads_to_injectable_body?(path)
-              body = inject_hot_reload_javascript(body)
-            end
-
-            [status, headers, body]
-          end
-        end
-
-        def close
-          @streams.close
-        end
-
-        def notify_streams_of_file_change(modified, added, removed)
-          @broadcast_hooks.each do |hook|
-            hook.call(modified, added, removed, streams: @streams)
-          end
-        end
-
-        private
-
-        def request_is_html?(headers)
-          headers["content-type"]&.start_with?("text/html")
-        end
-
-        def leads_to_injectable_body?(path)
-          path !~ /.+\/sandbox/
-        end
-
-        def inject_hot_reload_javascript(body)
-          @script_injector&.inject(body: body, dir: __dir__, mode: @mode)
-        end
-
-        def create_stream
-          stream = @streams.new
-
-          @ctx.debug("[HotReload] Connected to SSE stream")
-
-          [
-            200,
-            {
-              "Content-Type" => "text/event-stream",
-              "Cache-Control" => "no-cache",
-              "webrick.chunked" => true,
-            },
-            stream,
-          ]
-        end
-      end
-    end
-  end
-end

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

@@ -1,101 +0,0 @@
-# frozen_string_literal: true
-
-module ShopifyCLI
-  module Theme
-    class DevServer
-      class LocalAssets
-        SUPPORTED_EXTENSIONS = [:js, :css].join("|")
-        CDN_REGEX = %r{(//cdn)\.shopify\.com/s/.+?/(assets/.+?\.(?:#{SUPPORTED_EXTENSIONS}))}
-        VANITY_CDN_REGEX = %r{(/cdn)/shop/.+?/(assets/.+?\.(?:#{SUPPORTED_EXTENSIONS}))}
-
-        class FileBody
-          def initialize(path)
-            @path = path
-          end
-
-          # Naive implementation. Only used in unit tests.
-          def each
-            yield @path.read
-          end
-
-          # Rack will stream a body that responds to `to_path`
-          def to_path
-            @path.to_path
-          end
-        end
-
-        def initialize(ctx, app, target)
-          @ctx = ctx
-          @app = app
-          @target = target
-        end
-
-        def call(env)
-          path_info = env["PATH_INFO"]
-          if path_info.start_with?("/assets")
-            # Serve from disk
-            serve_file(path_info)
-          else
-            # Proxy the request, and replace the URLs in the response
-            status, headers, body = @app.call(env)
-            body = replace_asset_urls(body) unless path_info.start_with?("/fonts")
-            [status, headers, body]
-          end
-        end
-
-        def shop_regex
-          %r{(http:|https:)?//#{shop}/(assets/.+?\.(?:#{SUPPORTED_EXTENSIONS}))}
-        end
-
-        private
-
-        def replace_asset_urls(body)
-          replaced_body = body.join
-          [CDN_REGEX, VANITY_CDN_REGEX, shop_regex].each do |regex|
-            replaced_body = replaced_body.gsub(regex) do |match|
-              path = Regexp.last_match[2]
-              @target.static_asset_paths.include?(path) ? "/#{path}" : match
-            end
-          end
-
-          [replaced_body]
-        rescue ArgumentError => error
-          return [body.join] if error.message.include?("invalid byte sequence")
-
-          raise error
-        end
-
-        def serve_fail(status, body)
-          [
-            status,
-            {
-              "Content-Type" => "text/plain",
-              "Content-Length" => body.size.to_s,
-            },
-            [body],
-          ]
-        end
-
-        def serve_file(path_info)
-          path = @target.root.join(path_info[1..-1])
-          if path.file? && path.readable? && @target.static_asset_file?(path)
-            [
-              200,
-              {
-                "Content-Type" => MimeType.by_filename(path).to_s,
-                "Content-Length" => path.size.to_s,
-              },
-              FileBody.new(path),
-            ]
-          else
-            serve_fail(404, "Not found")
-          end
-        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/proxy.rb

@@ -1,313 +0,0 @@
-# frozen_string_literal: true
-
-require "stringio"
-require "time"
-require "cgi"
-require "net/http"
-
-require_relative "header_hash"
-require_relative "proxy_param_builder"
-
-module ShopifyCLI
-  module Theme
-    class DevServer
-      HOP_BY_HOP_HEADERS = [
-        "connection",
-        "keep-alive",
-        "proxy-authenticate",
-        "proxy-authorization",
-        "te",
-        "trailer",
-        "transfer-encoding",
-        "upgrade",
-        "content-security-policy",
-        "content-length",
-      ]
-
-      class Proxy
-        SESSION_COOKIE_NAME = "_shopify_essential"
-        SESSION_COOKIE_REGEXP = /#{SESSION_COOKIE_NAME}=([^;]*)(;|$)/
-        SESSION_COOKIE_MAX_AGE = 60 * 60 * 23 # 1 day - leeway of 1h
-        IGNORED_ENDPOINTS = %w[
-          shopify/monorail
-          mini-profiler-resources
-          web-pixels-manager
-          wpm
-        ]
-
-        def initialize(ctx, theme, param_builder, cache_cleaned = false)
-          @ctx = ctx
-          @theme = theme
-          @param_builder = param_builder
-          @cache_cleaned = cache_cleaned
-
-          @core_endpoints = Set.new
-          @secure_session_id = nil
-          @last_session_cookie_refresh = nil
-        end
-
-        def call(env)
-          return [204, {}, []] if IGNORED_ENDPOINTS.any? { |endpoint| env["PATH_INFO"].include?(endpoint) }
-
-          headers = extract_http_request_headers(env)
-          is_chrome = headers["User-Agent"] =~ /[Cc]hrome/
-          headers["Host"] = shop
-          headers["Cookie"] = add_session_cookie(headers["Cookie"])
-          headers["Accept-Encoding"] = "none"
-          headers["User-Agent"] = "Shopify CLI"
-          query = URI.decode_www_form(env["QUERY_STRING"])
-          replace_templates = build_replacement_param(env)
-
-          response = set_preview_theme_id(env, query, headers)
-          return serve_response(response, env) if response
-
-          response = if replace_templates.any?
-            # Pass to SFR the recently modified templates in `replace_templates` or
-            # `replace_extension_templates` body param
-            headers["Authorization"] = "Bearer #{bearer_token}"
-            form_data = URI.decode_www_form(env["rack.input"].read).to_h
-            request(
-              "POST", env["PATH_INFO"],
-              headers: headers,
-              query: query,
-              form_data: form_data.merge(replace_templates).merge(_method: env["REQUEST_METHOD"])
-            )
-          else
-            request(
-              env["REQUEST_METHOD"], env["PATH_INFO"],
-              headers: headers,
-              query: query,
-              body_stream: (env["rack.input"] if has_body?(headers))
-            )
-          end
-
-          headers = get_response_headers(response, env)
-          headers = modify_headers(headers) unless is_chrome
-
-          unless headers["x-storefront-renderer-rendered"]
-            @core_endpoints << env["PATH_INFO"]
-          end
-
-          serve_response(response, env, headers)
-        end
-
-        def secure_session_id
-          if secure_session_id_expired?
-            @ctx.debug("Refreshing preview _shopify_essential cookie")
-            response = request("HEAD", "/", query: [[:preview_theme_id, theme_id]])
-            @secure_session_id = extract_shopify_essential_from_response_headers(response)
-            @last_session_cookie_refresh = Time.now
-          end
-
-          @secure_session_id
-        end
-
-        private
-
-        def serve_response(response, env, headers = get_response_headers(response, env))
-          body = patch_body(env, response.body)
-          body = [body] unless body.respond_to?(:each)
-          [response.code, headers, body]
-        end
-
-        def set_preview_theme_id(env, query, headers)
-          if env["PATH_INFO"].start_with?("/password")
-            @cache_cleaned = false
-            return
-          end
-
-          return if @cache_cleaned
-
-          @cache_cleaned = true
-
-          query = query.dup
-          query << ["preview_theme_id", theme_id]
-
-          request(
-            env["REQUEST_METHOD"], env["PATH_INFO"],
-            headers: headers,
-            query: query,
-            body_stream: (env["rack.input"] if has_body?(headers))
-          )
-        end
-
-        def patch_body(env, body)
-          return [""] unless body
-
-          # Patch custom font asset urls
-          body = body.gsub(
-            %r{(url\((["']))?(http:|https:)?//#{shop}(?!/cdn/fonts)(/.*?\.(woff2?|eot|ttf))(\?[^'"\)]*)?(\2\))?\s*}
-          ) do |_|
-            match = Regexp.last_match
-            "#{match[1]}http://#{host(env)}#{match[4]}#{match[6]}#{match[7]} "
-          end
-
-          # Patch data-base-url attributes
-          body = body.gsub(%r{(data-base-url=(["']))(http:|https:)?//#{shop}(.*?)(\2)}) do |_|
-            match = Regexp.last_match
-            "#{match[1]}http://#{host(env)}#{match[4]}#{match[5]}"
-          end
-
-          body
-        end
-
-        def host(env)
-          env["HTTP_HOST"]
-        end
-
-        def has_body?(headers)
-          headers["Content-Length"] || headers["Transfer-Encoding"]
-        end
-
-        def bearer_token
-          Environment.storefront_renderer_auth_token ||
-            ShopifyCLI::DB.get(:storefront_renderer_production_exchange_token) ||
-            raise(KeyError, "storefront_renderer_production_exchange_token missing")
-        end
-
-        def extract_http_request_headers(env)
-          headers = HeaderHash.new
-
-          env.each do |name, value|
-            next if value.nil?
-
-            if /^HTTP_[A-Z0-9_]+$/.match?(name) || name == "CONTENT_TYPE" || name == "CONTENT_LENGTH"
-              headers[reconstruct_header_name(name)] = value
-            end
-          end
-
-          x_forwarded_for = (headers["X-Forwarded-For"].to_s.split(/, +/) << env["REMOTE_ADDR"]).join(", ")
-          headers["X-Forwarded-For"] = x_forwarded_for
-
-          headers
-        end
-
-        def normalize_headers(headers)
-          mapped = headers.map do |k, v|
-            [k, v.is_a?(Array) ? v.join("\n") : v]
-          end
-          HeaderHash.new(Hash[mapped])
-        end
-
-        def reconstruct_header_name(name)
-          name.sub(/^HTTP_/, "").gsub("_", "-")
-        end
-
-        def add_session_cookie(cookie_header)
-          cookie_header = if cookie_header
-            cookie_header.dup
-          else
-            +""
-          end
-
-          expected_session_cookie = "#{SESSION_COOKIE_NAME}=#{secure_session_id};"
-
-          unless cookie_header.include?(SESSION_COOKIE_NAME)
-            cookie_header << "; " unless cookie_header.empty?
-            cookie_header << expected_session_cookie
-          end
-
-          cookie_header
-        end
-
-        def secure_session_id_expired?
-          return true unless @secure_session_id && @last_session_cookie_refresh
-
-          Time.now - @last_session_cookie_refresh >= SESSION_COOKIE_MAX_AGE
-        end
-
-        def extract_shopify_essential_from_response_headers(headers)
-          return unless headers["set-cookie"]
-
-          headers["set-cookie"][SESSION_COOKIE_REGEXP, 1]
-        end
-
-        def get_response_headers(response, env)
-          response_headers = normalize_headers(
-            response.respond_to?(:headers) ? response.headers : response.to_hash,
-          )
-          # According to https://tools.ietf.org/html/draft-ietf-httpbis-p1-messaging-14#section-7.1.3.1Acc
-          # should remove hop-by-hop header fields
-          # (Taken from Rack::Proxy)
-          response_headers.reject! { |k| HOP_BY_HOP_HEADERS.include?(k.downcase) }
-
-          if response_headers["location"]&.include?("myshopify.com") ||
-            response_headers["location"]&.include?("spin.dev")
-            response_headers["location"].gsub!(%r{(https://#{shop})}, "http://#{host(env)}")
-          end
-
-          new_session_id = extract_shopify_essential_from_response_headers(response_headers)
-          if new_session_id
-            @ctx.debug("Renew _shopify_essential cookie by the response")
-            @secure_session_id = secure_session_id
-          end
-
-          response_headers
-        end
-
-        def request(method, path, headers: nil, query: [], form_data: nil, body_stream: nil)
-          uri = URI.join("https://#{shop}", path)
-
-          if proxy_via_theme_access_app?(path)
-            headers = headers ? headers.slice("ACCEPT", "CONTENT-TYPE", "CONTENT-LENGTH", "Cookie") : {}
-            headers.merge!({
-              "X-Shopify-Access-Token" => Environment.admin_auth_token,
-              "X-Shopify-Shop" => shop,
-            })
-            uri = URI.join("https://#{ShopifyCLI::Constants::ThemeKitAccess::BASE_URL}", "cli/sfr#{path}")
-          end
-
-          uri.query = URI.encode_www_form(query + [[:_fd, 0], [:pb, 0]])
-
-          @ctx.debug("Proxying #{method} #{uri}")
-
-          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(headers) if headers
-            req.set_form_data(form_data) if form_data
-            req.body_stream = body_stream if body_stream
-            response = http.request(req)
-            @ctx.debug("`-> #{response.code} request_id: #{response["x-request-id"]}")
-            response
-          end
-        end
-
-        def shop
-          @shop ||= @theme.shop
-        end
-
-        def theme_id
-          @theme_id ||= @theme.id
-        end
-
-        def build_replacement_param(env)
-          @param_builder
-            .with_core_endpoints(@core_endpoints)
-            .with_rack_env(env)
-            .build
-        end
-
-        def proxy_via_theme_access_app?(path)
-          return false unless Environment.theme_access_password?
-          return false if path == "/localization"
-          return false if path.start_with?("/cart/")
-
-          true
-        end
-
-        def modify_headers(headers)
-          if headers["set-cookie"]&.include?("storefront_digest")
-            headers["set-cookie"] = modify_set_cookie_header_for_safari(headers["set-cookie"])
-          end
-
-          headers
-        end
-
-        def modify_set_cookie_header_for_safari(set_cookie_header)
-          set_cookie_header.gsub("secure;", "secure: false;")
-        end
-      end
-    end
-  end
-end

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

@@ -1,84 +0,0 @@
-# frozen_string_literal: true
-
-require "cgi"
-
-module ShopifyCLI
-  module Theme
-    class DevServer
-      class ProxyParamBuilder
-        def build
-          # Core doesn't support replace_templates
-          return {} if core?(current_path)
-
-          (syncer_templates + request_templates)
-            .select { |file| file.liquid? || file.json? }
-            .uniq(&:relative_path)
-            .map { |file| as_param(file) }
-            .to_h
-        end
-
-        def with_core_endpoints(core_endpoints)
-          @core_endpoints = core_endpoints
-          self
-        end
-
-        def with_syncer(syncer)
-          @syncer = syncer
-          self
-        end
-
-        def with_rack_env(rack_env)
-          @rack_env = rack_env
-          self
-        end
-
-        def with_theme(theme)
-          @theme = theme
-          self
-        end
-
-        private
-
-        def as_param(file)
-          ["replace_templates[#{file.relative_path}]", file.read]
-        end
-
-        def syncer_templates
-          @syncer&.pending_updates || []
-        end
-
-        def request_templates
-          cookie_sections
-            .map { |section| @theme[section] unless @theme.nil? }
-            .compact
-        end
-
-        def cookie_sections
-          CGI::Cookie.parse(cookie)["hot_reload_files"].join.split(",") || []
-        rescue StandardError
-          []
-        end
-
-        def core?(path)
-          core_endpoints.include?(path)
-        end
-
-        def current_path
-          rack_env["PATH_INFO"]
-        end
-
-        def cookie
-          rack_env["HTTP_COOKIE"]
-        end
-
-        def core_endpoints
-          @core_endpoints || []
-        end
-
-        def rack_env
-          @rack_env || {}
-        end
-      end
-    end
-  end
-end

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

@@ -1,34 +0,0 @@
-# frozen_string_literal: true
-
-module ShopifyCLI
-  module Theme
-    class DevServer
-      class ReloadMode
-        MODES = [:"hot-reload", :"full-page", :off]
-
-        class << self
-          def default
-            :"hot-reload"
-          end
-
-          def get!(mode)
-            MODES.find { |m| m == mode.to_sym } || raise_error(mode)
-          end
-
-          private
-
-          def raise_error(invalid_mode)
-            error_message = ShopifyCLI::Context.message("theme.serve.reload_mode_is_not_valid", invalid_mode)
-            help_message = ShopifyCLI::Context.message("theme.serve.try_a_valid_reload_mode", valid_modes)
-
-            ShopifyCLI::Context.abort(error_message, help_message)
-          end
-
-          def valid_modes
-            MODES.map { |v| "`#{v}`" }.join(", ")
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,35 +0,0 @@
-# frozen_string_literal: true
-
-require "shopify_cli/thread_pool/job"
-
-module ShopifyCLI
-  module Theme
-    class DevServer
-      class RemoteWatcher
-        class JsonFilesUpdateJob < ShopifyCLI::ThreadPool::Job
-          def initialize(theme, syncer, interval)
-            super(interval)
-
-            @theme = theme
-            @syncer = syncer
-          end
-
-          def perform!
-            @syncer.fetch_checksums!
-            @syncer.enqueue_get(json_files)
-          end
-
-          private
-
-          def json_files
-            @theme
-              .json_files
-              .reject { |file| @syncer.pending_updates.include?(file) }
-              .reject { |file| @syncer.broken_file?(file) }
-              .reject { |file| @syncer.ignore_file?(file) }
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,44 +0,0 @@
-# frozen_string_literal: true
-
-require "shopify_cli/thread_pool"
-
-require_relative "remote_watcher/json_files_update_job"
-
-module ShopifyCLI
-  module Theme
-    class DevServer
-      class RemoteWatcher
-        SYNC_INTERVAL = 3 # seconds
-
-        class << self
-          def to(theme:, syncer:)
-            new(theme, syncer)
-          end
-        end
-
-        def start
-          thread_pool.schedule(recurring_job)
-        end
-
-        def stop
-          thread_pool.shutdown
-        end
-
-        private
-
-        def initialize(theme, syncer)
-          @theme = theme
-          @syncer = syncer
-        end
-
-        def thread_pool
-          @thread_pool ||= ShopifyCLI::ThreadPool.new(pool_size: 1)
-        end
-
-        def recurring_job
-          JsonFilesUpdateJob.new(@theme, @syncer, SYNC_INTERVAL)
-        end
-      end
-    end
-  end
-end