universal_renderer 0.2.4 → 0.3.1

data/app/controllers/concerns/universal_renderer/rendering.rb

@@ -1,132 +0,0 @@
-module UniversalRenderer
-  module Rendering
-    extend ActiveSupport::Concern
-
-    included do
-      include ActionController::Live
-      helper UniversalRenderer::SsrHelpers
-      before_action :initialize_props
-    end
-
-    private
-
-    def default_render
-      return super unless request.format.html?
-      if use_ssr_streaming?
-        render_ssr_stream
-      else
-        @ssr =
-          UniversalRenderer::StaticClient.static(
-            request.original_url,
-            @universal_renderer_props
-          )
-        super
-      end
-    end
-
-    def render_ssr_stream
-      set_streaming_headers
-
-      full_layout = render_to_string
-
-      split_index = full_layout.index("<!-- SSR_META -->")
-      before_meta = full_layout[0...split_index]
-      after_meta = full_layout[split_index..]
-
-      response.stream.write(before_meta)
-
-      current_props = @universal_renderer_props.dup
-
-      streaming_succeeded =
-        UniversalRenderer::StreamClient.stream(
-          request.original_url,
-          current_props,
-          after_meta,
-          response
-        )
-
-      handle_ssr_stream_fallback(response) unless streaming_succeeded
-    end
-
-    def initialize_props
-      @universal_renderer_props = {}
-    end
-
-    def add_props(key_or_hash, data_value = nil)
-      if data_value.nil? && key_or_hash.is_a?(Hash)
-        @universal_renderer_props.merge!(key_or_hash.deep_stringify_keys)
-      else
-        @universal_renderer_props[key_or_hash.to_s] = data_value
-      end
-    end
-
-    # Allows a prop to be treated as an array, pushing new values to it.
-    # If the prop does not exist or is nil, it's initialized as an array.
-    # If the prop exists but is not an array (e.g., set as a scalar by `add_props`),
-    # its current value will be converted into the first element of the new array.
-    # If `value_to_add` is an array, its elements are concatenated. Otherwise, `value_to_add` is appended.
-    def push_prop(key, value_to_add)
-      prop_key = key.to_s
-      current_value = @universal_renderer_props[prop_key]
-
-      if current_value.nil?
-        @universal_renderer_props[prop_key] = []
-      elsif !current_value.is_a?(Array)
-        @universal_renderer_props[prop_key] = [current_value]
-      end
-      # At this point, @universal_renderer_props[prop_key] is guaranteed to be an array.
-
-      if value_to_add.is_a?(Array)
-        @universal_renderer_props[prop_key].concat(value_to_add)
-      else
-        @universal_renderer_props[prop_key] << value_to_add
-      end
-    end
-
-    def use_ssr_streaming?
-      %w[1 true yes y].include?(ENV["ENABLE_SSR_STREAMING"]&.downcase)
-    end
-
-    def set_streaming_headers
-      # Tell Cloudflare / proxies not to cache or buffer.
-      response.headers["Cache-Control"] = "no-cache, no-store, must-revalidate"
-      response.headers["Pragma"] = "no-cache"
-      response.headers["Expires"] = "0"
-
-      # Disable Nginx buffering per-response.
-      response.headers["X-Accel-Buffering"] = "no"
-      response.headers["Content-Type"] = "text/html"
-
-      # Remove Content-Length header to prevent buffering.
-      response.headers.delete("Content-Length")
-    end
-
-    def handle_ssr_stream_fallback(response)
-      # SSR streaming failed or was not possible (e.g. server down, config missing).
-      # Ensure response hasn't been touched in a way that prevents a new render.
-      return unless response.committed? || response.body.present?
-
-      Rails.logger.error(
-        "SSR stream fallback:" \
-          "Cannot render default fallback template because response was already committed or body present."
-      )
-      # Close the stream if it's still open to prevent client connection from hanging
-      # when we can't render a fallback page due to already committed response
-      response.stream.close unless response.stream.closed?
-      # If response not committed, no explicit render is called here,
-      # allowing Rails' default rendering behavior to take over.
-    end
-
-    # Overrides the built-in render_to_string.
-    # If you call render_to_string with no explicit template/partial/inline,
-    # it will fall back to 'ssr/index'.
-    def render_to_string(options = {}, *args, &block)
-      if options.is_a?(Hash) && !options.key?(:template) &&
-           !options.key?(:partial) && !options.key?(:inline) &&
-           !options.key?(:json) && !options.key?(:xml)
-        options = options.merge(template: "application/index")
-      end
-      super(options, *args, &block)
-    end
-  end
-end

data/app/helpers/universal_renderer/ssr_helpers.rb

@@ -1,19 +0,0 @@
-module UniversalRenderer
-  module SsrHelpers
-    def ssr_meta
-      "<!-- SSR_META -->".html_safe
-    end
-
-    def ssr_body
-      "<!-- SSR_BODY -->".html_safe
-    end
-
-    def sanitize_ssr(html)
-      sanitize(html, scrubber: SsrScrubber.new)
-    end
-
-    def use_ssr_streaming?
-      %w[1 true yes y].include?(ENV["ENABLE_SSR_STREAMING"]&.downcase)
-    end
-  end
-end

data/app/services/universal_renderer/static_client.rb

@@ -1,56 +0,0 @@
-# frozen_string_literal: true
-
-require "net/http"
-require "json" # Ensure JSON is required for parsing and generation
-require "uri" # Ensure URI is required for URI parsing
-
-module UniversalRenderer
-  class StaticClient
-    class << self
-      # Performs a POST request to the SSR service to get statically rendered content.
-      #
-      # @param url [String] The URL of the page to render.
-      # @param props [Hash] Additional data to be passed for rendering (renamed from query_data for clarity).
-      # @return [Hash, nil] The parsed JSON response as symbolized keys if successful, otherwise nil.
-      def static(url, props)
-        ssr_url = UniversalRenderer.config.ssr_url
-        return if ssr_url.blank?
-
-        timeout = UniversalRenderer.config.timeout
-
-        begin
-          uri = URI.parse(ssr_url)
-          http = Net::HTTP.new(uri.host, uri.port)
-          http.use_ssl = (uri.scheme == "https")
-          http.open_timeout = timeout
-          http.read_timeout = timeout
-
-          request = Net::HTTP::Post.new(uri.request_uri) # Use uri.request_uri to include path if present in ssr_url
-          request.body = { url: url, props: props }.to_json
-          request["Content-Type"] = "application/json"
-
-          response = http.request(request)
-
-          if response.is_a?(Net::HTTPSuccess)
-            JSON.parse(response.body).deep_symbolize_keys
-          else
-            Rails.logger.error(
-              "SSR static request to #{ssr_url} failed: #{response.code} - #{response.message} (URL: #{url})"
-            )
-            nil
-          end
-        rescue Net::OpenTimeout, Net::ReadTimeout => e
-          Rails.logger.error(
-            "SSR static request to #{ssr_url} timed out: #{e.class.name} - #{e.message} (URL: #{url})"
-          )
-          nil
-        rescue StandardError => e
-          Rails.logger.error(
-            "SSR static request to #{ssr_url} failed: #{e.class.name} - #{e.message} (URL: #{url})"
-          )
-          nil
-        end
-      end
-    end
-  end
-end

data/app/services/universal_renderer/stream_client/error_logger.rb

@@ -1,29 +0,0 @@
-module UniversalRenderer
-  class StreamClient
-    module ErrorLogger
-      class << self
-        def _log_setup_error(error, target_uri_string)
-          backtrace_info = error.backtrace&.first || "No backtrace available"
-          Rails.logger.error(
-            "Unexpected error during SSR stream setup for #{target_uri_string}: " \
-              "#{error.class.name} - #{error.message} at #{backtrace_info}"
-          )
-        end
-
-        def _log_connection_error(error, target_uri_string)
-          Rails.logger.error(
-            "SSR stream connection to #{target_uri_string} failed: #{error.class.name} - #{error.message}"
-          )
-        end
-
-        def _log_unexpected_error(error, target_uri_string, context_message)
-          backtrace_info = error.backtrace&.first || "No backtrace available"
-          Rails.logger.error(
-            "#{context_message} for #{target_uri_string}: " \
-              "#{error.class.name} - #{error.message} at #{backtrace_info}"
-          )
-        end
-      end
-    end
-  end
-end

data/app/services/universal_renderer/stream_client/execution.rb

@@ -1,88 +0,0 @@
-module UniversalRenderer
-  class StreamClient
-    module Execution
-      class << self
-        def _perform_streaming(
-          http_client,
-          http_post_request,
-          response,
-          stream_uri
-        )
-          http_client.request(http_post_request) do |node_res|
-            Execution._handle_node_response_streaming(
-              node_res,
-              response,
-              stream_uri
-            )
-
-            return true
-          end
-          false
-        end
-
-        def _handle_node_response_streaming(node_res, response, stream_uri)
-          if node_res.is_a?(Net::HTTPSuccess)
-            Execution._stream_response_body(node_res, response.stream)
-          else
-            Execution._handle_streaming_for_node_error(
-              node_res,
-              response,
-              stream_uri
-            )
-          end
-        rescue StandardError => e
-          Rails.logger.error(
-            "Error during SSR data transfer or stream writing from #{stream_uri}: #{e.class.name} - #{e.message}"
-          )
-
-          Execution._write_generic_html_error(
-            response.stream,
-            "Streaming Error",
-            "<p>A problem occurred while loading content. Please refresh.</p>"
-          )
-        ensure
-          response.stream.close unless response.stream.closed?
-        end
-
-        def _stream_response_body(source_http_response, target_io_stream)
-          source_http_response.read_body do |chunk|
-            target_io_stream.write(chunk)
-          end
-        end
-
-        def _handle_streaming_for_node_error(node_res, response, stream_uri)
-          Rails.logger.error(
-            "SSR stream server at #{stream_uri} responded with #{node_res.code} #{node_res.message}."
-          )
-
-          is_potentially_viewable_error =
-            node_res["Content-Type"]&.match?(%r{text/html}i)
-
-          if is_potentially_viewable_error
-            Rails.logger.info(
-              "Attempting to stream HTML error page from Node SSR server."
-            )
-            Execution._stream_response_body(node_res, response.stream)
-          else
-            Rails.logger.warn(
-              "Node SSR server error response Content-Type ('#{node_res["Content-Type"]}') is not text/html. " \
-                "Injecting generic error message into the stream."
-            )
-
-            Execution._write_generic_html_error(
-              response.stream,
-              "Application Error",
-              "<p>There was an issue rendering this page. Please try again later.</p>"
-            )
-          end
-        end
-
-        def _write_generic_html_error(stream, title_text, message_html_fragment)
-          return if stream.closed?
-
-          stream.write("<h1>#{title_text}</h1>#{message_html_fragment}")
-        end
-      end
-    end
-  end
-end

data/app/services/universal_renderer/stream_client/setup.rb

@@ -1,37 +0,0 @@
-module UniversalRenderer
-  class StreamClient
-    module Setup
-      class << self
-        def _ensure_ssr_server_url_configured?(config)
-          config.ssr_url.present?
-        end
-
-        def _build_stream_request_components(body, config)
-          # Ensure ssr_url is present, though _ensure_ssr_server_url_configured? should have caught this.
-          # However, direct calls to this method might occur, so a check or reliance on config.ssr_url is important.
-          if config.ssr_url.blank?
-            raise ArgumentError, "SSR URL is not configured."
-          end
-
-          parsed_ssr_url = URI.parse(config.ssr_url)
-          stream_uri = URI.join(parsed_ssr_url, config.ssr_stream_path)
-
-          http = Net::HTTP.new(stream_uri.host, stream_uri.port)
-          http.use_ssl = (stream_uri.scheme == "https")
-          http.open_timeout = config.timeout
-          http.read_timeout = config.timeout
-
-          http_request =
-            Net::HTTP::Post.new(
-              stream_uri.request_uri,
-              "Content-Type" => "application/json"
-            )
-
-          http_request.body = body.to_json
-
-          [stream_uri, http, http_request]
-        end
-      end
-    end
-  end
-end

data/app/services/universal_renderer/stream_client.rb

@@ -1,84 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "stream_client/setup"
-require_relative "stream_client/execution"
-require_relative "stream_client/error_logger"
-
-module UniversalRenderer
-  class StreamClient
-    extend Setup
-    extend Execution
-    extend ErrorLogger
-
-    # Orchestrates the streaming process for server-side rendering.
-    #
-    # @param url [String] The URL of the page to render.
-    # @param props [Hash] Data to be passed for rendering, including layout HTML.
-    # @param template [String] The HTML template to use for rendering.
-    # @param response [ActionDispatch::Response] The Rails response object to stream to.
-    # @return [Boolean] True if streaming was initiated, false otherwise.
-    def self.stream(url, props, template, response)
-      config = UniversalRenderer.config
-
-      unless Setup._ensure_ssr_server_url_configured?(config)
-        Rails.logger.warn(
-          "StreamClient: SSR URL (config.ssr_url) is not configured. Falling back."
-        )
-        return false
-      end
-
-      stream_uri_obj = nil
-      full_ssr_url_for_log = config.ssr_url.to_s # For logging in case of early error
-
-      begin
-        body = { url: url, props: props, template: template }
-
-        actual_stream_uri, http_client, http_post_request =
-          Setup._build_stream_request_components(body, config)
-
-        stream_uri_obj = actual_stream_uri
-
-        full_ssr_url_for_log = actual_stream_uri.to_s # Update for more specific logging
-      rescue URI::InvalidURIError => e
-        Rails.logger.error(
-          "StreamClient: SSR stream failed due to invalid URI ('#{config.ssr_url}'): #{e.message}"
-        )
-
-        return false
-      rescue StandardError => e
-        _log_setup_error(e, full_ssr_url_for_log)
-
-        return false
-      end
-
-      Execution._perform_streaming(
-        http_client,
-        http_post_request,
-        response,
-        stream_uri_obj
-      )
-    rescue Errno::ECONNREFUSED,
-           Errno::EHOSTUNREACH,
-           Net::OpenTimeout,
-           Net::ReadTimeout,
-           SocketError => e
-      uri_str_for_conn_error =
-        stream_uri_obj ? stream_uri_obj.to_s : full_ssr_url_for_log
-
-      ErrorLogger._log_connection_error(e, uri_str_for_conn_error)
-
-      false
-    rescue StandardError => e
-      uri_str_for_unexpected_error =
-        stream_uri_obj ? stream_uri_obj.to_s : full_ssr_url_for_log
-
-      ErrorLogger._log_unexpected_error(
-        e,
-        uri_str_for_unexpected_error,
-        "StreamClient: Unexpected error during SSR stream process"
-      )
-
-      false
-    end
-  end
-end

data/lib/universal_renderer/ssr_scrubber.rb

@@ -1,61 +0,0 @@
-require "loofah"
-
-module UniversalRenderer
-  class SsrScrubber < ::Loofah::Scrubber
-    def initialize
-      super
-      @direction = :top_down
-    end
-
-    def scrub(node)
-      # Primary actions: stop if script, continue if a passthrough tag, otherwise clean attributes.
-      return Loofah::Scrubber::STOP if handle_script_node(node) # Checks for <script> and removes it
-
-      # Allows <link rel="stylesheet">, <style>, <meta> to pass through this scrubber.
-      return Loofah::Scrubber::CONTINUE if passthrough_node?(node)
-
-      # For all other nodes, clean potentially harmful attributes.
-      clean_attributes(node)
-      # Default Loofah behavior (CONTINUE for children) applies if not returned earlier.
-    end
-
-    private
-
-    # Handles <script> tags: removes them and returns true if a script node was processed.
-    def handle_script_node(node)
-      return false unless node.name == "script"
-
-      node.remove
-      true # Indicates the node was a script and has been handled.
-    end
-
-    # Checks if the node is a type that should bypass detailed attribute scrubbing.
-    def passthrough_node?(node)
-      (node.name == "link" && node["rel"]&.to_s&.downcase == "stylesheet") ||
-        %w[style meta].include?(node.name)
-    end
-
-    # Orchestrates the cleaning of attributes for a given node.
-    def clean_attributes(node)
-      remove_javascript_href(node)
-      remove_event_handlers(node)
-    end
-
-    # Removes "javascript:" hrefs from <a> tags.
-    def remove_javascript_href(node)
-      if node.name == "a" &&
-           node["href"]&.to_s&.downcase&.start_with?("javascript:")
-        node.remove_attribute("href")
-      end
-    end
-
-    # Removes "on*" event handler attributes from any node.
-    def remove_event_handlers(node)
-      attrs_to_remove =
-        node.attributes.keys.select do |name|
-          name.to_s.downcase.start_with?("on")
-        end
-      attrs_to_remove.each { |attr_name| node.remove_attribute(attr_name) }
-    end
-  end
-end