reactive_views 0.1.0

data/lib/reactive_views/full_page_renderer.rb

@@ -0,0 +1,158 @@
+# frozen_string_literal: true
+
+require "json"
+require "erb"
+
+module ReactiveViews
+  # Renders full-page TSX.ERB templates via ERB→TSX→SSR pipeline
+  class FullPageRenderer
+    require "securerandom"
+
+    class << self
+      # Render a full-page TSX.ERB template
+      #
+      # @param controller [ActionController::Base] The controller instance
+      # @param template_full_path [String] Full path to .tsx.erb template
+      # @return [String] SSR HTML
+      def render(controller, template_full_path:)
+        # Step 1: Render ERB to produce TSX
+        tsx_content = render_erb(controller, template_full_path)
+
+        # Determine extension from path
+        extension = template_full_path.to_s.end_with?(".jsx.erb") ? "jsx" : "tsx"
+
+        render_content(controller, tsx_content, extension: extension, identifier: template_full_path)
+      end
+
+      # Render from raw content (used by TemplateHandler)
+      #
+      # @param controller [ActionController::Base] The controller instance
+      # @param content [String] The TSX/JSX content
+      # @param extension [String] 'tsx' or 'jsx'
+      # @return [String] SSR HTML
+      def render_content(controller, content, extension: "tsx", identifier: nil)
+        sanitized_content = sanitize_jsx_content(content)
+
+        temp_file = TempFileManager.write(
+          sanitized_content,
+          identifier: identifier || controller.controller_name,
+          extension: extension
+        )
+
+        props = PropsBuilder.build(controller.view_context, sanitized_content, extension: extension)
+
+        render_result = Renderer.render_path_with_metadata(temp_file.path, props)
+        html = render_result[:html]
+        bundle_key = render_result[:bundle_key]
+
+        # Check for error marker and show fullscreen overlay in development
+        if html.to_s.start_with?("___REACTIVE_VIEWS_ERROR___")
+          error_message = html.sub("___REACTIVE_VIEWS_ERROR___", "").sub(/___\z/, "")
+          component_name = identifier ? File.basename(identifier.to_s, ".*") : "FullPage"
+          return ErrorOverlay.generate_fullscreen(
+            component_name: component_name,
+            props: props,
+            errors: [ { message: error_message } ]
+          )
+        end
+
+        return html if bundle_key.nil?
+
+        wrap_with_hydration(html, props, bundle_key)
+      ensure
+        temp_file&.delete
+      end
+
+      private
+
+      def render_erb(controller, template_path)
+        # Create a view context with the controller's instance variables
+        view_context = controller.view_context
+
+        # CRITICAL: Set the lookup context to use :tsx format so partials resolve correctly
+        # This ensures that when ERB processes <%= render "users/filters" %>, it looks for _filters.tsx.erb
+        # Only modify lookup_context if it exists (may be a mock in tests)
+        if view_context.respond_to?(:lookup_context) && view_context.lookup_context
+          original_formats = view_context.lookup_context.formats.dup
+          original_handlers = view_context.lookup_context.handlers.dup
+
+          begin
+            # Set formats to include :tsx so partials are found
+            view_context.lookup_context.formats = %i[tsx html]
+            # Ensure :tsx handler is in the lookup
+            view_context.lookup_context.handlers = %i[tsx erb raw html builder ruby]
+
+            # Read the template source
+            template_source = File.read(template_path)
+
+            # Render ERB with [:tsx] format so partials resolve correctly
+            erb_handler = ActionView::Template.handler_for_extension("erb")
+
+            # Create a temporary template object
+            # Note: template_path must be a String, not Pathname
+            template = ActionView::Template.new(
+              template_source,
+              template_path.to_s,
+              erb_handler,
+              locals: [],
+              format: :tsx,
+              variant: nil,
+              virtual_path: nil
+            )
+
+            # Render the template in the view context
+            template.render(view_context, {})
+          ensure
+            # Restore original lookup context
+            view_context.lookup_context.formats = original_formats
+            view_context.lookup_context.handlers = original_handlers
+          end
+        else
+          # Fallback for mocks or when lookup_context is not available
+          # Read the template source
+          template_source = File.read(template_path)
+
+          # Render ERB with [:tsx] format so partials resolve correctly
+          erb_handler = ActionView::Template.handler_for_extension("erb")
+
+          # Create a temporary template object
+          template = ActionView::Template.new(
+            template_source,
+            template_path.to_s,
+            erb_handler,
+            locals: [],
+            format: :tsx,
+            variant: nil,
+            virtual_path: nil
+          )
+
+          # Render the template in the view context
+          template.render(view_context, {})
+        end
+      end
+
+      def sanitize_jsx_content(content)
+        return "" if content.nil?
+
+        source = content.respond_to?(:to_str) ? content.to_str : content.to_s
+        return source unless source.include?("<!--")
+
+        source.gsub(/<!--\s*(BEGIN|END)\s+app\/views.*?-->\s*/m, "")
+      end
+
+      def wrap_with_hydration(html, props, bundle_key)
+        uuid = SecureRandom.uuid
+        metadata = {
+          props: props || {},
+          bundle: bundle_key
+        }
+        metadata_json = JSON.generate(metadata).gsub("</", "<\\/")
+
+        container = %(<div data-reactive-page="true" data-page-uuid="#{uuid}">#{html}</div>)
+        props_script = %(<script type="application/json" data-page-uuid="#{uuid}">#{metadata_json}</script>)
+
+        "#{container}#{props_script}"
+      end
+    end
+  end
+end

data/lib/reactive_views/helpers.rb

@@ -0,0 +1,209 @@
+# frozen_string_literal: true
+
+module ReactiveViewsHelper
+  # Single helper that includes everything needed for ReactiveViews to work.
+  # This abstracts away Vite implementation details for a better developer experience.
+  #
+  # Usage in your application layout:
+  #   <%= reactive_views_script_tag %>
+  #
+  # This helper automatically includes:
+  # - Vite client (for HMR in development)
+  # - Vite JavaScript entrypoint (which imports the boot script)
+  # - SSR URL meta tag for client runtime
+  #
+  # In production, it serves precompiled assets from the Vite manifest.
+  def reactive_views_script_tag
+    output = []
+
+    # Advertise SSR URL for the client runtime
+    # In production, this should point to the SSR service
+    ssr_url = resolve_ssr_url
+    output << tag.meta(name: "reactive-views-ssr-url", content: ssr_url)
+
+    # Production mode: serve precompiled assets
+    if production_mode?
+      output << production_script_tags
+    else
+      # Development/test mode: use Vite dev server
+      output << development_script_tags
+    end
+
+    safe_join(output.flatten.compact, "\n")
+  end
+
+  # Returns the asset host URL for CDN deployments
+  # Can be configured via:
+  # - ReactiveViews.config.asset_host
+  # - ENV['ASSET_HOST']
+  # - Rails.application.config.asset_host
+  def reactive_views_asset_host
+    ReactiveViews.config.asset_host ||
+      ENV["ASSET_HOST"] ||
+      (defined?(Rails) && Rails.application.config.asset_host)
+  end
+
+  # @deprecated Use {#reactive_views_script_tag} instead.
+  # This helper is maintained for backward compatibility but will be removed in future versions.
+  def reactive_views_boot
+    warn "[DEPRECATION] `reactive_views_boot` is deprecated. Please use `reactive_views_script_tag` instead."
+    javascript_include_tag(
+      ReactiveViews.config.boot_module_path || "/vite/assets/reactive_views_boot.js",
+      defer: true,
+      crossorigin: "anonymous"
+    )
+  end
+
+  private
+
+  def production_mode?
+    return false unless defined?(Rails)
+
+    Rails.env.production?
+  end
+
+  def resolve_ssr_url
+    # In production, use the Rails proxy endpoint for same-origin requests
+    # This allows the SSR server to run on localhost without being publicly exposed
+    if production_mode?
+      # Return the Rails-mounted proxy path (relative URL)
+      "/reactive_views"
+    else
+      # In development, allow direct access for debugging
+      # Allow configuration override, then environment variable, then default
+      ReactiveViews.config.ssr_url ||
+        ENV.fetch("REACTIVE_VIEWS_SSR_URL", "http://localhost:5175")
+    end
+  end
+
+  def production_script_tags
+    output = []
+
+    begin
+      # In production, vite_rails handles manifest resolution
+      # The vite_javascript_tag will automatically use the manifest
+      if respond_to?(:vite_javascript_tag)
+        output << vite_javascript_tag("application")
+      else
+        # Fallback: manually resolve from manifest
+        output << manual_production_script_tag
+      end
+    rescue StandardError => e
+      log_helper_error("production_script_tags", e)
+      # Return a helpful error comment in development-like environments
+      output << "<!-- ReactiveViews: Error loading production assets: #{e.message} -->".html_safe
+    end
+
+    output
+  end
+
+  def development_script_tags
+    output = []
+
+    # In Rails test env, vite_rails typically prefers manifest mode and will raise if
+    # the test manifest isn't built. Our own system specs run with a Vite dev server,
+    # so we emit direct dev-server module URLs instead of relying on vite_rails helpers.
+    if defined?(Rails) && Rails.env.test?
+      vite_port = ENV.fetch("RV_VITE_PORT", "5174")
+      vite_base = "vite-test"
+      # Use 127.0.0.1 to avoid IPv6/localhost resolution differences in headless browsers.
+      dev_host = "http://127.0.0.1:#{vite_port}"
+
+      output << tag.script(type: "module", src: "#{dev_host}/#{vite_base}/@vite/client")
+      # @vitejs/plugin-react expects the react-refresh preamble to be installed.
+      preamble = <<~JS
+        import RefreshRuntime from "#{dev_host}/#{vite_base}/@react-refresh";
+        RefreshRuntime.injectIntoGlobalHook(window);
+        window.$RefreshReg$ = () => {};
+        window.$RefreshSig$ = () => (type) => type;
+        window.__vite_plugin_react_preamble_installed__ = true;
+      JS
+      output << content_tag(:script, preamble.html_safe, type: "module")
+      output << tag.script(type: "module", src: "#{dev_host}/#{vite_base}/entrypoints/application.js")
+      return output
+    end
+
+    # Include Vite client tag for HMR in development
+    output << vite_client_tag if respond_to?(:vite_client_tag)
+
+    # Ensure React Refresh preamble is installed BEFORE any TSX runs (development only, NOT in test)
+    # NOTE: vite_rails proxies Vite at a base path (e.g., /vite-dev/), so we need the full path
+    begin
+      if defined?(Rails) && Rails.env.development?
+        vite_base = resolve_vite_base_path
+
+        preamble = <<~JS
+          import RefreshRuntime from "/#{vite_base}/@react-refresh";
+          RefreshRuntime.injectIntoGlobalHook(window);
+          window.$RefreshReg$ = () => {};
+          window.$RefreshSig$ = () => (type) => type;
+          window.__vite_plugin_react_preamble_installed__ = true;
+        JS
+        output << content_tag(:script, preamble.html_safe, type: "module")
+      end
+    rescue StandardError => e
+      log_helper_error("react_refresh_preamble", e)
+    end
+
+    # Include the Vite JavaScript entrypoint
+    # The boot script is imported in application.js and bundled by Vite
+    output << vite_javascript_tag("application") if respond_to?(:vite_javascript_tag)
+
+    output
+  end
+
+  def resolve_vite_base_path
+    ViteRuby.config.public_output_dir
+  rescue StandardError
+    "vite-dev"
+  end
+
+  def manual_production_script_tag
+    # Fallback for when vite_rails helpers are not available
+    # This reads the manifest directly and generates the appropriate script tag
+    manifest_path = Rails.root.join("public", "vite", ".vite", "manifest.json")
+
+    unless File.exist?(manifest_path)
+      # Try alternate manifest location
+      manifest_path = Rails.root.join("public", "vite", "manifest.json")
+    end
+
+    unless File.exist?(manifest_path)
+      raise ReactiveViews::AssetManifestNotFoundError,
+            "Vite manifest not found. Run 'bin/vite build' to precompile assets."
+    end
+
+    manifest = JSON.parse(File.read(manifest_path))
+    entry = manifest["app/javascript/entrypoints/application.js"] || manifest["application.js"]
+
+    unless entry
+      raise ReactiveViews::AssetEntryNotFoundError,
+            "Application entry not found in Vite manifest. Check your vite.config.ts entry points."
+    end
+
+    asset_path = build_asset_path(entry["file"])
+
+    # Include CSS if present
+    css_tags = (entry["css"] || []).map do |css_file|
+      tag.link(rel: "stylesheet", href: build_asset_path(css_file))
+    end
+
+    script_tag = tag.script(src: asset_path, type: "module", crossorigin: "anonymous")
+
+    safe_join([ css_tags, script_tag ].flatten, "\n")
+  end
+
+  def build_asset_path(file)
+    host = reactive_views_asset_host
+    path = "/vite/#{file}"
+
+    host ? "#{host.chomp('/')}#{path}" : path
+  end
+
+  def log_helper_error(method_name, error)
+    return unless defined?(Rails) && Rails.logger
+
+    Rails.logger.error("[ReactiveViews] Helper error: #{method_name} failed - #{error.message}")
+    Rails.logger.debug(error.backtrace.join("\n")) if Rails.logger.debug?
+  end
+end

data/lib/reactive_views/props_builder.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+require "set"
+
+module ReactiveViews
+  class PropsBuilder
+    class << self
+      def build(view_context, content, extension: "tsx")
+        controller = view_context.controller
+
+        # Collect instance variables
+        assigns = view_context.assigns.deep_symbolize_keys
+
+        # Merge with explicit reactive_view_props
+        explicit_props = if controller.respond_to?(:reactive_view_props, true)
+                           controller.send(:reactive_view_props)
+        else
+                           {}
+        end
+
+        all_props = assigns.merge(explicit_props)
+
+        return all_props unless ReactiveViews.config.props_inference_enabled
+
+        # Infer which props the component actually needs
+        inferred_keys = PropsInference.infer_props(content, extension: extension)
+
+        # If inference succeeded, filter to only inferred keys ∪ explicit keys
+        if inferred_keys.any?
+          inferred_set = inferred_keys.map(&:to_sym).to_set
+          explicit_set = explicit_props.keys.to_set
+          allowed_keys = inferred_set | explicit_set
+
+          all_props.select { |key, _| allowed_keys.include?(key) }
+        else
+          # On inference failure, pass all props
+          all_props
+        end
+      end
+    end
+  end
+end

data/lib/reactive_views/props_inference.rb

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+require "digest"
+require "net/http"
+require "json"
+require "uri"
+
+module ReactiveViews
+  # Props inference client to extract prop keys from TSX component signatures
+  class PropsInference
+    class InferenceError < StandardError; end
+
+    class << self
+      def cache
+        inference_cache
+      end
+
+      # Infer prop keys from TSX component signature
+      #
+      # @param tsx_content [String] The TSX/JSX source code
+      # @param extension [String] The source extension ('tsx' or 'jsx')
+      # @return [Array<String>] Array of prop keys, or empty array on failure
+      def infer_props(tsx_content, extension: "tsx")
+        return [] unless ReactiveViews.config.props_inference_enabled
+
+        # Generate cache key from content digest
+        content_digest = Digest::SHA256.hexdigest(tsx_content)
+        ttl = ReactiveViews.config.props_inference_cache_ttl_seconds
+        cache_store = inference_cache
+
+        if ttl && (cached = cache_store.read(content_digest))
+          return cached
+        end
+
+        # Make inference request
+        keys = make_inference_request(tsx_content, content_digest, extension)
+
+        # Cache the result
+        cache_store.write(content_digest, keys, ttl: ttl) if ttl
+
+        keys
+      rescue StandardError => e
+        log_error("Props inference failed: #{e.message}")
+        [] # Return empty array on failure
+      end
+
+      private
+
+      def inference_cache
+        ReactiveViews.config.cache_for(:props_inference)
+      end
+
+      def make_inference_request(tsx_content, content_digest, extension)
+        # Ensure SSR process is running (auto-spawns in production if not manually configured)
+        SsrProcess.ensure_running
+
+        uri = URI.parse("#{ReactiveViews.config.ssr_url}/infer-props")
+        http = Net::HTTP.new(uri.host, uri.port)
+        http.read_timeout = ReactiveViews.config.ssr_timeout
+
+        request = Net::HTTP::Post.new(uri.path, "Content-Type" => "application/json")
+        request.body = JSON.generate({
+                                       tsxContent: tsx_content,
+                                       contentHash: content_digest,
+                                       extension: (extension || "tsx").to_s
+                                     })
+
+        response = http.request(request)
+
+        raise InferenceError, "HTTP #{response.code}: #{response.body}" unless response.is_a?(Net::HTTPSuccess)
+
+        result = JSON.parse(response.body)
+        result["keys"] || []
+      rescue JSON::ParserError => e
+        raise InferenceError, "Invalid JSON response: #{e.message}"
+      rescue Errno::ECONNREFUSED, Errno::EHOSTUNREACH => e
+        raise InferenceError, "Cannot connect to SSR server: #{e.message}"
+      rescue Net::ReadTimeout
+        raise InferenceError, "Inference request timed out"
+      end
+
+      def log_error(message)
+        return unless defined?(Rails) && Rails.logger
+
+        Rails.logger.error("[ReactiveViews::PropsInference] #{message}")
+      end
+    end
+  end
+end

data/lib/reactive_views/railtie.rb

@@ -0,0 +1,93 @@
+# frozen_string_literal: true
+
+# Load vite_rails to ensure ViteRails constant is available
+begin
+  require "vite_rails"
+rescue LoadError
+  # If vite_rails is not installed, the helper will show an appropriate error
+end
+
+module ReactiveViews
+  class Railtie < Rails::Railtie
+    # Load rake tasks
+    rake_tasks do
+      load File.expand_path("../tasks/reactive_views.rake", __dir__)
+    end
+
+    initializer "reactive_views.helpers" do
+      ActiveSupport.on_load(:action_view) do
+        include ReactiveViewsHelper
+      end
+    end
+
+    initializer "reactive_views.controller_props" do
+      ActiveSupport.on_load(:action_controller) do
+        require_relative "controller_props"
+        include ReactiveViews::ControllerProps
+
+        helper_method :reactive_view_props if respond_to?(:helper_method)
+      end
+    end
+
+    # Register :tsx and :jsx MIME types and handler
+    initializer "reactive_views.register_template_handlers", before: :load_config_initializers do
+      # Register :tsx and :jsx as aliases for HTML so lookups and formats behave
+      begin
+        Mime::Type.register_alias "text/html", :tsx unless Mime::Type.lookup_by_extension(:tsx)
+        Mime::Type.register_alias "text/html", :jsx unless Mime::Type.lookup_by_extension(:jsx)
+      rescue StandardError
+        # no-op if Mime::Type is unavailable
+      end
+
+      ActiveSupport.on_load(:action_view) do
+        require_relative "template_handler"
+        ActionView::Template.register_template_handler :tsx, ReactiveViews::TemplateHandler
+        ActionView::Template.register_template_handler :jsx, ReactiveViews::TemplateHandler
+      end
+    end
+
+    # Register custom resolver to support HTML -> TSX -> JSX lookup
+    initializer "reactive_views.setup_resolver", after: :load_config_initializers do
+      Rails.logger&.info("[ReactiveViews] Initializing resolver...")
+      ActiveSupport.on_load(:action_controller) do
+        require_relative "resolver"
+
+        # Add the resolver for app/views
+        views_path = Rails.root.join("app", "views")
+        Rails.logger&.info("[ReactiveViews] Views path: #{views_path}")
+        if Dir.exist?(views_path)
+          Rails.logger&.info("[ReactiveViews] Prepending resolver for #{views_path}")
+          prepend_view_path ReactiveViews::Resolver.new(views_path.to_s)
+        else
+          Rails.logger&.warn("[ReactiveViews] Views path does not exist!")
+        end
+      end
+    end
+
+    # Hook into ActionView to transform component tags in rendered HTML
+    initializer "reactive_views.transform_components", after: :load_config_initializers do
+      ActiveSupport.on_load(:action_controller) do
+        ActionController::Base.class_eval do
+          around_action :transform_reactive_views_components
+
+          private
+
+          def transform_reactive_views_components
+            yield  # Let controller exceptions bubble up naturally to rescue_from handlers
+
+            # Only transform HTML responses
+            if response.content_type&.include?("text/html") && response.body.present?
+              begin
+                response.body = ReactiveViews::TagTransformer.transform(response.body)
+              rescue StandardError => e
+                # Log transformation errors but don't break the response
+                Rails.logger&.error("[ReactiveViews] Transformation error: #{e.message}")
+                Rails.logger&.error(e.backtrace.join("\n")) if e.backtrace
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end