rhales 0.4.0 → 0.5.3

data/lib/rhales/{template_engine.rb → core/template_engine.rb}

@@ -1,10 +1,12 @@
 # lib/rhales/template_engine.rb
+#
+# frozen_string_literal: true
 
 require 'erb'
-require_relative 'parsers/rue_format_parser'
-require_relative 'parsers/handlebars_parser'
+require_relative '../parsers/rue_format_parser'
+require_relative '../parsers/handlebars_parser'
 require_relative 'rue_document'
-require_relative 'hydrator'
+require_relative '../hydration/hydrator'
 
 module Rhales
   # Rhales - Ruby Handlebars-style template engine
@@ -28,6 +30,8 @@ module Rhales
   # - {{#each items}} ... {{/each}} - Iteration with context
   # - {{> partial_name}} - Partial inclusion
   class TemplateEngine
+    include Rhales::Utils::LoggingHelpers
+
     class RenderError < ::Rhales::RenderError; end
     class PartialNotFoundError < RenderError; end
     class UndefinedVariableError < RenderError; end
@@ -43,31 +47,46 @@ module Rhales
     end
 
     def render
-      # Check if this is a simple template or a full .rue file
-      if simple_template?
-        # Use HandlebarsParser for simple templates
-        parser = HandlebarsParser.new(@template_content)
-        parser.parse!
-        render_content_nodes(parser.ast.children)
-      else
-        # Use RueDocument for .rue files
-        @parser = RueDocument.new(@template_content)
-        @parser.parse!
+      template_type = simple_template? ? :handlebars : :rue
+
+      log_timed_operation(Rhales.logger, :debug, 'Template compiled',
+        template_type: template_type, cached: false
+      ) do
+        # Check if this is a simple template or a full .rue file
+        if simple_template?
+          # Use HandlebarsParser for simple templates
+          parser = HandlebarsParser.new(@template_content)
+          parser.parse!
+          render_content_nodes(parser.ast.children)
+        else
+          # Use RueDocument for .rue files
+          @parser = RueDocument.new(@template_content)
+          @parser.parse!
 
-        # Get template section via RueDocument
-        template_content = @parser.section('template')
-        raise RenderError, 'Missing template section' unless template_content
+          # Get template section via RueDocument
+          template_content = @parser.section('template')
+          raise RenderError, 'Missing template section' unless template_content
 
-        # Render the template section as a simple template
-        render_template_string(template_content)
+          # Render the template section as a simple template
+          render_template_string(template_content)
+        end
       end
     rescue ::Rhales::ParseError => ex
       # Parse errors already have good error messages with location
+      log_with_metadata(Rhales.logger, :error, 'Template parse error',
+        error: ex.message, line: ex.line, column: ex.column, section: ex.source_type
+      )
       raise RenderError, "Template parsing failed: #{ex.message}"
     rescue ::Rhales::ValidationError => ex
       # Validation errors from RueDocument
+      log_with_metadata(Rhales.logger, :error, 'Template validation error',
+        error: ex.message, template_type: :rue
+      )
       raise RenderError, "Template validation failed: #{ex.message}"
     rescue StandardError => ex
+      log_with_metadata(Rhales.logger, :error, 'Template render error',
+        error: ex.message, error_class: ex.class.name
+      )
       raise RenderError, "Template rendering failed: #{ex.message}"
     end
 
@@ -81,11 +100,6 @@ module Rhales
       @parser&.schema_path
     end
 
-    # Access all data attributes from parsed .rue file
-    def data_attributes
-      @parser&.data_attributes || {}
-    end
-
     # Get template variables used in the template
     def template_variables
       @parser&.template_variables || []
@@ -99,7 +113,7 @@ module Rhales
     private
 
     def simple_template?
-      !@template_content.match?(/^<(data|template|logic)\b/)
+      !@template_content.match?(/^<(schema|template|logic)\b/)
     end
 
     def render_template_string(template_string)
@@ -131,7 +145,7 @@ module Rhales
         when :each_block
           result += render_each_block(node)
         when :handlebars_expression
-          # Handle old format for data sections
+          # Handle handlebars expressions
           result += render_handlebars_expression(node)
         end
       end
@@ -144,7 +158,13 @@ module Rhales
       raw  = node.value[:raw]
 
       value = get_variable_value(name)
-      raw ? value.to_s : escape_html(value.to_s)
+
+      if raw
+        warn_if_unescaped(name, value, 'variable_expression')
+        value.to_s
+      else
+        escape_html(value.to_s)
+      end
     end
 
     def render_partial_expression(node)
@@ -205,7 +225,12 @@ module Rhales
         ''
       else # Variables
         value = get_variable_value(content)
-        raw ? value.to_s : escape_html(value.to_s)
+        if raw
+          warn_if_unescaped(content, value, 'handlebars_expression')
+          value.to_s
+        else
+          escape_html(value.to_s)
+        end
       end
     end
 
@@ -216,8 +241,8 @@ module Rhales
       raise PartialNotFoundError, "Partial '#{partial_name}' not found" unless partial_content
 
       # Check if this is a .rue document with sections
-      if partial_content.match?(/^<(data|template|logic)\b/)
-        # Parse as RueDocument to handle data sections properly
+      if partial_content.match?(/^<(schema|template|logic)\b/)
+        # Parse as RueDocument to handle schema sections properly
         partial_doc = RueDocument.new(partial_content)
         partial_doc.parse!
 
@@ -225,19 +250,8 @@ module Rhales
         template_content = partial_doc.section('template')
         raise PartialNotFoundError, "Partial '#{partial_name}' missing template section" unless template_content
 
-        # Process data section if present and merge with parent context
-        merged_context = @context
-        if partial_doc.section('data')
-          # Create hydrator with parent context to process interpolations
-          hydrator = Hydrator.new(partial_doc, @context)
-          local_data = hydrator.processed_data_hash
-
-          # Create merged context (local data takes precedence)
-          merged_context = create_merged_context(@context, local_data)
-        end
-
-        # Render template with merged context
-        engine = self.class.new(template_content, merged_context, partial_resolver: @partial_resolver)
+        # Render template with current context
+        engine = self.class.new(template_content, @context, partial_resolver: @partial_resolver)
         engine.render
       else
         # Simple template without sections - render as before
@@ -264,6 +278,16 @@ module Rhales
       end
     end
 
+    # Log warning for unescaped variable usage unless whitelisted
+    def warn_if_unescaped(variable_name, value, template_context)
+      return if Rhales.config.allowed_unescaped_variables.include?(variable_name.to_s)
+
+      log_with_metadata(
+        Rhales.logger, :warn, 'Unescaped variable usage',
+        variable: variable_name, value_type: value.class.name, template_context: template_context
+      )
+    end
+
     # Evaluate condition for if/unless blocks
     def evaluate_condition(condition)
       value = get_variable_value(condition)
@@ -297,23 +321,6 @@ module Rhales
       ERB::Util.html_escape(string)
     end
 
-    # Create a new context with merged data
-    def create_merged_context(parent_context, local_data)
-      # Extract all props from parent context and merge with local data
-      # Local data takes precedence over parent props
-      merged_props = parent_context.props.merge(local_data)
-
-      # Create new context with merged props, preserving other context attributes
-      Context.for_view(
-        parent_context.req,
-        parent_context.sess,
-        parent_context.cust,
-        parent_context.locale,
-        config: parent_context.config,
-        **merged_props,
-      )
-    end
-
     # Context wrapper for {{#each}} iterations
     class EachContext
       attr_reader :parent_context, :current_item, :current_index, :items_var

data/lib/rhales/{view.rb → core/view.rb}

@@ -1,14 +1,18 @@
 # lib/rhales/view.rb
+#
+# frozen_string_literal: true
 
 require 'securerandom'
+require 'forwardable'
 require_relative 'context'
 require_relative 'rue_document'
 require_relative 'template_engine'
-require_relative 'hydrator'
+require_relative '../hydration/hydrator'
 require_relative 'view_composition'
-require_relative 'hydration_data_aggregator'
-require_relative 'csp'
-require_relative 'refinements/require_refinements'
+require_relative '../hydration/hydration_data_aggregator'
+require_relative '../security/csp'
+require_relative '../utils/json_serializer'
+require_relative '../integrations/refinements/require_refinements'
 
 using Rhales::Ruequire
 
@@ -27,14 +31,15 @@ module Rhales
   #
   # ### Server Templates: Full Context Access
   # Templates have complete access to all server-side data:
-  # - All props passed to View.new
-  # - Data from .rue file's <data> section (processed server-side)
+  # - All client data passed to View.new
+  # - All server data passed to View.new
+
   # - Runtime data (CSRF tokens, nonces, request metadata)
   # - Computed data (authentication status, theme classes)
   # - User objects, configuration, internal APIs
   #
   # ### Client Data: Explicit Allowlist
-  # Only data declared in <data> sections reahas_role?ches the browser:
+  # Only client data declared in <schema> sections reaches the browser:
   # - Creates a REST API-like boundary
   # - Server-side variable interpolation processes secrets safely
   # - JSON serialization validates data structure
@@ -44,53 +49,83 @@ module Rhales
   #   # Server template has full access:
   #   {{user.admin?}} {{csrf_token}} {{internal_config}}
   #
-  #   # Client only gets declared data:
-  #   { "user_name": "{{user.name}}", "theme": "{{user.theme}}" }
+  #   # Client only gets declared data from schema:
+  #   <schema lang="js-zod" window="data">
+  #   const schema = z.object({ userName: z.string() });
+  #   </schema>
   #
   # See docs/CONTEXT_AND_DATA_BOUNDARIES.md for complete details.
   #
   # Subclasses can override context_class to use different context implementations.
   class View
+    extend Forwardable
+    include Rhales::Utils::LoggingHelpers
+
     class RenderError < StandardError; end
     class TemplateNotFoundError < RenderError; end
 
-    attr_reader :req, :sess, :cust, :locale, :rsfc_context, :props, :config
+    attr_reader :req, :rsfc_context
 
-    def initialize(req, sess = nil, cust = nil, locale_override = nil, props: {}, config: nil)
-      @req           = req
-      @sess          = sess
-      @cust          = cust
-      @locale        = locale_override
-      @props         = props
-      @config        = config || Rhales.configuration
+    # Delegate context accessors to rsfc_context
+    def_delegators :@rsfc_context, :sess, :user, :client, :server, :config, :locale
 
-      # Create context using the specified context class
-      @rsfc_context = create_context
+    def initialize(req, client: {}, server: {}, config: nil)
+      @req = req
+      @rsfc_context = context_class.for_view(req, client: client, server: server, config: config || Rhales.configuration)
     end
 
     # Render RSFC template with hydration using two-pass architecture
     def render(template_name = nil)
+      start_time = now_in_μs
       template_name ||= self.class.default_template_name
 
-      # Phase 1: Build view composition and aggregate data
-      composition           = build_view_composition(template_name)
-      aggregator            = HydrationDataAggregator.new(@rsfc_context)
-      merged_hydration_data = aggregator.aggregate(composition)
+      # Store template name in request env for middleware validation
+      @req.env['rhales.template_name'] = template_name if @req && @req.respond_to?(:env)
 
-      # Phase 2: Render HTML with pre-computed data
-      # Render template content
-      template_html = render_template_with_composition(composition, template_name)
+      begin
+        # Phase 1: Build view composition and aggregate data
+        composition           = build_view_composition(template_name)
+        aggregator            = HydrationDataAggregator.new(@rsfc_context)
+        merged_hydration_data = aggregator.aggregate(composition)
 
-      # Generate hydration HTML with merged data
-      hydration_html = generate_hydration_from_merged_data(merged_hydration_data)
+        # Phase 2: Render HTML with pre-computed data
+        # Render template content
+        template_html = render_template_with_composition(composition, template_name)
 
-      # Set CSP header if enabled
-      set_csp_header_if_enabled
+        # Generate hydration HTML with merged data
+        hydration_html = generate_hydration_from_merged_data(merged_hydration_data)
 
-      # Smart hydration injection with mount point detection
-      inject_hydration_with_mount_points(composition, template_name, template_html, hydration_html)
-    rescue StandardError => ex
-      raise RenderError, "Failed to render template '#{template_name}': #{ex.message}"
+        # Set CSP header if enabled
+        set_csp_header_if_enabled
+
+        # Smart hydration injection with mount point detection
+        result = inject_hydration_with_mount_points(composition, template_name, template_html, hydration_html)
+
+        # Log successful render
+        duration = now_in_μs - start_time
+        hydration_size = merged_hydration_data.to_json.bytesize if merged_hydration_data
+
+        log_with_metadata(Rhales.logger, :debug, 'View rendered',
+          template: template_name,
+          layout: composition.layout,
+          partials: composition.dependencies.values.flatten.uniq,
+          duration: duration,
+          hydration_size_bytes: hydration_size
+        )
+
+        result
+      rescue StandardError => ex
+        duration = now_in_μs - start_time
+
+        log_with_metadata(Rhales.logger, :error, 'View render failed',
+          template: template_name,
+          duration: duration,
+          error: ex.message,
+          error_class: ex.class.name
+        )
+
+        raise RenderError, "Failed to render template '#{template_name}': #{ex.message}"
+      end
     end
 
     # Render only the template section (without data hydration)
@@ -104,46 +139,46 @@ module Rhales
 
     # Render JSON response for API endpoints (link-based strategies)
     def render_json_only(template_name = nil, additional_context = {})
-      require_relative 'hydration_endpoint'
+      require_relative '../hydration/hydration_endpoint'
 
       template_name ||= self.class.default_template_name
-      endpoint = HydrationEndpoint.new(@config, @rsfc_context)
+      endpoint = HydrationEndpoint.new(config, @rsfc_context)
       endpoint.render_json(template_name, additional_context)
     end
 
     # Render ES module response for modulepreload strategy
     def render_module_only(template_name = nil, additional_context = {})
-      require_relative 'hydration_endpoint'
+      require_relative '../hydration/hydration_endpoint'
 
       template_name ||= self.class.default_template_name
-      endpoint = HydrationEndpoint.new(@config, @rsfc_context)
+      endpoint = HydrationEndpoint.new(config, @rsfc_context)
       endpoint.render_module(template_name, additional_context)
     end
 
     # Render JSONP response with callback
     def render_jsonp_only(template_name = nil, callback_name = 'callback', additional_context = {})
-      require_relative 'hydration_endpoint'
+      require_relative '../hydration/hydration_endpoint'
 
       template_name ||= self.class.default_template_name
-      endpoint = HydrationEndpoint.new(@config, @rsfc_context)
+      endpoint = HydrationEndpoint.new(config, @rsfc_context)
       endpoint.render_jsonp(template_name, callback_name, additional_context)
     end
 
     # Check if template data has changed for caching
     def data_changed?(template_name = nil, etag = nil, additional_context = {})
-      require_relative 'hydration_endpoint'
+      require_relative '../hydration/hydration_endpoint'
 
       template_name ||= self.class.default_template_name
-      endpoint = HydrationEndpoint.new(@config, @rsfc_context)
+      endpoint = HydrationEndpoint.new(config, @rsfc_context)
       endpoint.data_changed?(template_name, etag, additional_context)
     end
 
     # Calculate ETag for current template data
     def calculate_etag(template_name = nil, additional_context = {})
-      require_relative 'hydration_endpoint'
+      require_relative '../hydration/hydration_endpoint'
 
       template_name ||= self.class.default_template_name
-      endpoint = HydrationEndpoint.new(@config, @rsfc_context)
+      endpoint = HydrationEndpoint.new(config, @rsfc_context)
       endpoint.calculate_etag(template_name, additional_context)
     end
 
@@ -172,12 +207,6 @@ module Rhales
 
     protected
 
-    # Create the appropriate context for this view
-    # Subclasses can override this to use different context types
-    def create_context
-      context_class.for_view(@req, @sess, @cust, @locale, config: @config, **@props)
-    end
-
     # Return the context class to use
     # Subclasses can override this to use different context implementations
     def context_class
@@ -201,8 +230,8 @@ module Rhales
     # Resolve template path
     def resolve_template_path(template_name)
       # Check configured template paths first
-      if @config && @config.template_paths && !@config.template_paths.empty?
-        @config.template_paths.each do |path|
+      if config && config.template_paths && !config.template_paths.empty?
+        config.template_paths.each do |path|
           template_path = File.join(path, "#{template_name}.rue")
           return template_path if File.exist?(template_path)
         end
@@ -218,8 +247,8 @@ module Rhales
       return templates_path if File.exist?(templates_path)
 
       # Return first configured path or web path for error message
-      if @config && @config.template_paths && !@config.template_paths.empty?
-        File.join(@config.template_paths.first, "#{template_name}.rue")
+      if config && config.template_paths && !config.template_paths.empty?
+        File.join(config.template_paths.first, "#{template_name}.rue")
       else
         web_path
       end
@@ -235,10 +264,9 @@ module Rhales
     #
     # RSFC Security Model: Templates have full server context access
     # - Templates can access all business data, user objects, methods, etc.
-    # - Templates can access data from .rue file's <data> section (processed server-side)
     # - This is like any server-side template (ERB, HAML, etc.)
     # - Security boundary is at server-to-client handoff, not within server rendering
-    # - Only data declared in <data> section reaches the client (after processing)
+    # - Only data declared in <schema> section reaches the client (after validation)
     def render_template_section(parser)
       template_content = parser.section('template')
       return '' unless template_content
@@ -246,11 +274,8 @@ module Rhales
       # Create partial resolver
       partial_resolver = create_partial_resolver
 
-      # Merge .rue file data with existing context
-      context_with_rue_data = create_context_with_rue_data(parser)
-
-      # Render with full server context (props + computed context + rue data)
-      TemplateEngine.render(template_content, context_with_rue_data, partial_resolver: partial_resolver)
+      # Render with full server context
+      TemplateEngine.render(template_content, @rsfc_context, partial_resolver: partial_resolver)
     end
 
     # Create partial resolver for {{> partial}} inclusions
@@ -268,44 +293,12 @@ module Rhales
       end
     end
 
-    # Generate data hydration HTML
-    def generate_hydration(parser)
-      Hydrator.generate(parser, @rsfc_context)
-    end
-
-    # Create context that includes data from .rue file's data section
-    def create_context_with_rue_data(parser)
-      # Get data from .rue file's data section
-      rue_data = extract_rue_data(parser)
-
-      # Merge rue data with existing props (rue data takes precedence)
-      merged_props = @props.merge(rue_data)
-
-      # Create new context with merged data
-      context_class.for_view(@req, @sess, @cust, @locale, config: @config, **merged_props)
-    end
-
-    # Extract and process data from .rue file's data section
-    def extract_rue_data(parser)
-      data_content = parser.section('data')
-      return {} unless data_content
-
-      # Process the data section as JSON and parse it
-      hydrator = Hydrator.new(parser, @rsfc_context)
-      hydrator.processed_data_hash
-    rescue JSON::ParserError, Hydrator::JSONSerializationError => ex
-      puts "Error processing data section: #{ex.message}"
-      # If data section isn't valid JSON, return empty hash
-      # This allows templates to work even with malformed data sections
-      {}
-    end
-
     # Smart hydration injection with mount point detection on rendered HTML
     def inject_hydration_with_mount_points(composition, template_name, template_html, hydration_html)
-      injector = HydrationInjector.new(@config.hydration, template_name)
+      injector = HydrationInjector.new(config.hydration, template_name)
 
       # Check if using link-based strategy
-      if @config.hydration.link_based_strategy?
+      if config.hydration.link_based_strategy?
         # For link-based strategies, we need the merged data context
         aggregator = HydrationDataAggregator.new(@rsfc_context)
         merged_data = aggregator.aggregate(composition)
@@ -319,22 +312,11 @@ module Rhales
       end
     end
 
-    # Legacy injection method (kept for backwards compatibility)
-    def inject_hydration_into_template(template_html, hydration_html)
-      # Try to inject before closing </body> tag
-      if template_html.include?('</body>')
-        template_html.sub('</body>', "#{hydration_html}\n</body>")
-      # Otherwise append to end
-      else
-        "#{template_html}\n#{hydration_html}"
-      end
-    end
-
     # Detect mount points in fully rendered HTML
     def detect_mount_point_in_rendered_html(template_html)
-      return nil unless @config&.hydration
+      return nil unless config&.hydration
 
-      custom_selectors = @config.hydration.mount_point_selectors || []
+      custom_selectors = config.hydration.mount_point_selectors || []
       detector = MountPointDetector.new
       detector.detect(template_html, custom_selectors)
     end
@@ -342,7 +324,7 @@ module Rhales
     # Build view composition for the given template
     def build_view_composition(template_name)
       loader      = method(:load_template_for_composition)
-      composition = ViewComposition.new(template_name, loader: loader, config: @config)
+      composition = ViewComposition.new(template_name, loader: loader, config: config)
       composition.resolve!
     end
 
@@ -365,8 +347,8 @@ module Rhales
       # Create partial resolver that uses the composition
       partial_resolver = create_partial_resolver_from_composition(composition)
 
-      # Merge .rue file data with existing context
-      context_with_rue_data = create_context_with_rue_data(root_parser)
+      # Use existing context for rendering
+      context_with_rue_data = @rsfc_context
 
       # Check if template has a layout
       if root_parser.layout && composition.template(root_parser.layout)
@@ -378,16 +360,8 @@ module Rhales
         layout_content = layout_parser.section('template')
         return '' unless layout_content
 
-        # Create new context with content for layout rendering
-        layout_props   = context_with_rue_data.props.merge('content' => content_html)
-        layout_context = Context.new(
-          context_with_rue_data.req,
-          context_with_rue_data.sess,
-          context_with_rue_data.cust,
-          context_with_rue_data.locale,
-          props: layout_props,
-          config: context_with_rue_data.config,
-        )
+        # Use builder pattern to create new context with content for layout rendering
+        layout_context = context_with_rue_data.merge_client('content' => content_html)
 
         TemplateEngine.render(layout_content, layout_context, partial_resolver: partial_resolver)
       else
@@ -411,16 +385,16 @@ module Rhales
       merged_data.each do |window_attr, data|
         # Generate unique ID for this data block
         unique_id = "rsfc-data-#{SecureRandom.hex(8)}"
+        nonce_attr = nonce_attribute
 
         # Create JSON script tag with optional reflection attributes
-        json_attrs = reflection_enabled? ? " data-window=\"#{window_attr}\"" : ""
+        json_attrs = reflection_enabled? ? " data-window=\"#{window_attr}\"" : ''
         json_script = <<~HTML.strip
-          <script id="#{unique_id}" type="application/json"#{json_attrs}>#{JSON.generate(data)}</script>
+          <script#{nonce_attr} id="#{unique_id}" type="application/json"#{json_attrs}>#{JSONSerializer.dump(data)}</script>
         HTML
 
         # Create hydration script with optional reflection attributes
-        nonce_attr = nonce_attribute
-        hydration_attrs = reflection_enabled? ? " data-hydration-target=\"#{window_attr}\"" : ""
+        hydration_attrs = reflection_enabled? ? " data-hydration-target=\"#{window_attr}\"" : ''
         hydration_script = if reflection_enabled?
           <<~HTML.strip
             <script#{nonce_attr}#{hydration_attrs}>
@@ -446,12 +420,15 @@ module Rhales
         hydration_parts << generate_reflection_utilities
       end
 
-      hydration_parts.join("\n")
+      return '' if hydration_parts.empty?
+
+      hydration_content = hydration_parts.join("\n")
+      "\n\n<!-- Rhales Hydration Start -->\n#{hydration_content}\n<!-- Rhales Hydration End -->"
     end
 
     # Check if reflection system is enabled
     def reflection_enabled?
-      @config.hydration.reflection_enabled
+      config.hydration.reflection_enabled
     end
 
     # Generate JavaScript utilities for hydration reflection
@@ -512,14 +489,14 @@ module Rhales
 
     # Set CSP header if enabled
     def set_csp_header_if_enabled
-      return unless @config.csp_enabled
+      return unless config.csp_enabled
       return unless @req && @req.respond_to?(:env)
 
       # Get nonce from context
       nonce = @rsfc_context.get('nonce')
 
       # Create CSP instance and build header
-      csp = CSP.new(@config, nonce: nonce)
+      csp = CSP.new(config, nonce: nonce)
       header_value = csp.build_header
 
       # Set header in request environment for framework to use
@@ -537,15 +514,15 @@ module Rhales
           .sub(/_view$/, '')
       end
 
-      # Render template with props
-      def render_with_data(req, sess, cust, locale, template_name: nil, config: nil, **props)
-        view = new(req, sess, cust, locale, props: props, config: config)
+      # Render template with client data
+      def render_with_data(req, template_name: nil, config: nil, **client_data)
+        view = new(req, client: client_data, config: config)
         view.render(template_name)
       end
 
-      # Create view instance with props
-      def with_data(req, sess, cust, locale, config: nil, **props)
-        new(req, sess, cust, locale, props: props, config: config)
+      # Create view instance with client data
+      def with_data(req, config: nil, **client_data)
+        new(req, client: client_data, config: config)
       end
     end
   end