fluid_cli 0.1.2

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

@@ -0,0 +1,92 @@
+# frozen_string_literal: true
+
+module FluidCLI
+  module Theme
+    class DevServer
+      class LocalAssets
+        THEME_REGEX = %r{//cdn\.shopify\.com/s/.+?/(assets/.+?\.(?:css|js))}
+
+        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
+
+        private
+
+        def replace_asset_urls(body)
+          replaced_body = body.join.gsub(THEME_REGEX) do |match|
+            path = Regexp.last_match[1]
+            if @target.static_asset_paths.include?(path)
+              "/#{path}"
+            else
+              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
+      end
+    end
+  end
+end

data/lib/fluid_cli/theme/dev_server/proxy.rb

@@ -0,0 +1,235 @@
+# frozen_string_literal: true
+
+require "stringio"
+require "time"
+require "cgi"
+require "net/http"
+
+require_relative "header_hash"
+require_relative "proxy_param_builder"
+
+module FluidCLI
+  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 = "_fluid_session"
+        SESSION_COOKIE_REGEXP = /#{SESSION_COOKIE_NAME}=(\h+)/
+        SESSION_COOKIE_MAX_AGE = 60 * 60 * 23 # 1 day - leeway of 1h
+
+        def initialize(ctx, theme, param_builder)
+          @ctx = ctx
+          @theme = theme
+          @param_builder = param_builder
+
+          @core_endpoints = Set.new
+          @secure_session_id = nil
+          @last_session_cookie_refresh = nil
+        end
+
+        def call(env)
+          headers = extract_http_request_headers(env)
+          headers["Host"] = company_host
+          headers["Cookie"] = add_session_cookie(headers["Cookie"])
+          headers["Accept-Encoding"] = "none"
+          headers["X-Fluid-Theme"] = theme_id.to_s
+          headers["User-Agent"] = "Fluid CLI"
+          query = URI.decode_www_form(env["QUERY_STRING"])
+          replace_templates = build_replacement_param(env)
+          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)
+
+          @core_endpoints << env["PATH_INFO"]
+
+          body = patch_body(env, response.body)
+          body = [body] unless body.respond_to?(:each)
+          [response.code, headers, body]
+        end
+
+        private
+
+        def patch_body(env, body)
+          return [""] unless body
+
+          body.gsub(%r{(data-.+=(["']))(http:|https:)?//#{company}(.*)(\2)}) do |_|
+            match = Regexp.last_match
+            "#{match[1]}http://#{host(env)}#{match[4]}#{match[5]}"
+          end
+        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 ||
+            FluidCLI::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?(expected_session_cookie)
+            if cookie_header.include?(SESSION_COOKIE_NAME)
+              cookie_header.sub!(SESSION_COOKIE_REGEXP, expected_session_cookie)
+            else
+              cookie_header << "; " unless cookie_header.empty?
+              cookie_header << expected_session_cookie
+            end
+          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_secure_session_id_from_response_headers(headers)
+          return unless headers["set-cookie"]
+
+          headers["set-cookie"][SESSION_COOKIE_REGEXP, 1]
+        end
+
+        def secure_session_id
+          if secure_session_id_expired?
+            @ctx.debug("Refreshing preview _secure_session_id cookie")
+            response = request("HEAD", "/", query: [[:preview_theme_id, theme_id]])
+            @secure_session_id = extract_secure_session_id_from_response_headers(response)
+            @last_session_cookie_refresh = Time.now
+          end
+
+          @secure_session_id
+        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) }
+
+          new_session_id = extract_secure_session_id_from_response_headers(response_headers)
+          if new_session_id
+            @ctx.debug("New _secure_session_id cookie from response")
+            @secure_session_id = new_session_id
+            @last_session_cookie_refresh = Time.now
+          end
+
+          response_headers
+        end
+
+        def request(method, path, headers: nil, query: [], form_data: nil, body_stream: nil)
+          uri = URI.join("https://#{company_host}", path)
+
+          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 company
+          @company ||= @theme.company
+        end
+
+        def company_host
+          @company_host ||= "#{company}.fluid.app"
+        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
+      end
+    end
+  end
+end

data/lib/fluid_cli/theme/dev_server/proxy_param_builder.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+require "cgi"
+
+module FluidCLI
+  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(",") || []
+        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

data/lib/fluid_cli/theme/dev_server/reload_mode.rb

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

data/lib/fluid_cli/theme/dev_server/sse.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+require "thread"
+
+module FluidCLI
+  module Theme
+    class DevServer
+      # Server-Sent events implementation for Rack.
+      # Based on https://gist.github.com/raggi/ff7971991297e5c8a1ce
+      class SSE
+        class Event < Struct.new(:data)
+          def to_s
+            "data: #{data}\n" \
+            "\n\n"
+          end
+        end
+
+        class Stream
+          def initialize(streams)
+            @streams = streams
+            @queue = Queue.new
+          end
+
+          def <<(event)
+            raise TypeError, "expected SSE::Event" unless event.is_a?(Event)
+            @queue << event
+          end
+
+          def each
+            while (event = @queue.pop)
+              yield event.to_s
+            end
+          end
+
+          def close
+            @streams.remove(self)
+            @queue << nil
+          end
+        end
+
+        class Streams
+          def initialize
+            @list = []
+          end
+
+          def size
+            @list.size
+          end
+
+          def new
+            stream = Stream.new(self)
+            @list << stream
+            stream
+          end
+
+          def remove(stream)
+            raise TypeError, "expected SSE::Stream" unless stream.is_a?(Stream)
+            @list.delete(stream)
+          end
+
+          def broadcast(data)
+            raise TypeError, "expected String" unless data.is_a?(String)
+            @list.each do |stream|
+              stream << Event.new(data)
+            end
+          end
+
+          def close
+            @list.each(&:close)
+            @list.clear
+          end
+        end
+      end
+    end
+  end
+end

data/lib/fluid_cli/theme/dev_server/watcher.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+require "fluid_cli/file_system_listener"
+require "forwardable"
+
+module FluidCLI
+  module Theme
+    class DevServer
+      # Watches for file changes and publish events to the theme
+      class Watcher
+        extend Forwardable
+
+        def_delegators :@listener, :add_observer, :changed, :notify_observers
+
+        def initialize(ctx, theme:, syncer:, poll: false)
+          @ctx = ctx
+          @theme = theme
+          @syncer = syncer
+          @listener = FileSystemListener.new(root: @theme.root, force_poll: poll)
+
+          add_observer(self, :upload_files_when_changed)
+        end
+
+        def start
+          @listener.start
+        end
+
+        def stop
+          @listener.stop
+        end
+
+        def upload_files_when_changed(modified, added, removed)
+          modified_theme_files = filter_theme_files(modified + added)
+          if modified_theme_files.any?
+            @syncer.enqueue_updates(modified_theme_files)
+          end
+
+          removed_theme_files = filter_remote_files(removed)
+          if removed_theme_files.any?
+            @syncer.enqueue_deletes(removed_theme_files)
+          end
+        end
+
+        def filter_theme_files(files)
+          files
+            .select { |file| @theme.theme_file?(file) }
+            .map { |file| @theme[file] }
+        end
+
+        def filter_remote_files(files)
+          files
+            .select { |file| @syncer.remote_file?(file) }
+            .map { |file| @theme[file] }
+        end
+      end
+    end
+  end
+end