rhales 0.4.0 → 0.5.3

data/lib/rhales/utils/schema_extractor.rb

@@ -0,0 +1,132 @@
+# lib/rhales/schema_extractor.rb
+#
+# frozen_string_literal: true
+
+require 'pathname'
+require_relative '../core/rue_document'
+
+module Rhales
+  # Extracts schema definitions from .rue files
+  #
+  # This class scans template directories for .rue files containing <schema>
+  # sections and extracts the schema code along with metadata (attributes).
+  #
+  # Usage:
+  #   extractor = SchemaExtractor.new('./templates')
+  #   schemas = extractor.extract_all
+  #   schemas.each do |schema_info|
+  #     puts "#{schema_info[:template_name]}: #{schema_info[:lang]}"
+  #   end
+  class SchemaExtractor
+    class ExtractionError < StandardError; end
+
+    attr_reader :templates_dir
+
+    def initialize(templates_dir)
+      @templates_dir = File.expand_path(templates_dir)
+      validate_directory!
+    end
+
+    # Extract all schemas from .rue files in the templates directory
+    #
+    # @return [Array<Hash>] Array of schema information hashes
+    # @example
+    #   [
+    #     {
+    #       template_name: 'dashboard',
+    #       template_path: '/path/to/dashboard.rue',
+    #       schema_code: 'const schema = z.object({...});',
+    #       lang: 'ts-zod',
+    #       version: '2',
+    #       envelope: 'SuccessEnvelope',
+    #       window: 'appData',
+    #       merge: 'deep',
+    #       layout: 'layouts/main',
+    #       extends: nil
+    #     }
+    #   ]
+    def extract_all
+      rue_files = find_rue_files
+      schemas = []
+
+      rue_files.each do |file_path|
+        begin
+          schema_info = extract_from_file(file_path)
+          schemas << schema_info if schema_info
+        rescue => e
+          warn "Warning: Failed to extract schema from #{file_path}: #{e.message}"
+        end
+      end
+
+      schemas
+    end
+
+    # Extract schema from a single .rue file
+    #
+    # @param file_path [String] Path to the .rue file
+    # @return [Hash, nil] Schema information hash or nil if no schema section
+    def extract_from_file(file_path)
+      doc = RueDocument.parse_file(file_path)
+
+      return nil unless doc.section?('schema')
+
+      template_name = derive_template_name(file_path)
+      schema_code = doc.section('schema')
+
+      {
+        template_name: template_name,
+        template_path: file_path,
+        schema_code: schema_code.strip,
+        lang: doc.schema_lang,
+        version: doc.schema_version,
+        envelope: doc.schema_envelope,
+        window: doc.schema_window,
+        merge: doc.schema_merge_strategy,
+        layout: doc.schema_layout,
+        extends: doc.schema_extends
+      }
+    end
+
+    # Find all .rue files in the templates directory (recursive)
+    #
+    # @return [Array<String>] Array of absolute file paths
+    def find_rue_files
+      pattern = File.join(@templates_dir, '**', '*.rue')
+      Dir.glob(pattern).sort
+    end
+
+    # Count how many .rue files have schema sections
+    #
+    # @return [Hash] Count information
+    def schema_stats
+      all_files = find_rue_files
+      schemas = extract_all
+
+      {
+        total_files: all_files.count,
+        files_with_schemas: schemas.count,
+        files_without_schemas: all_files.count - schemas.count,
+        schemas_by_lang: schemas.group_by { |s| s[:lang] }.transform_values(&:count)
+      }
+    end
+
+    private
+
+    def validate_directory!
+      unless File.directory?(@templates_dir)
+        raise ExtractionError, "Templates directory does not exist: #{@templates_dir}"
+      end
+    end
+
+    # Derive template name from file path
+    # Examples:
+    #   /path/to/templates/dashboard.rue => 'dashboard'
+    #   /path/to/templates/pages/user/profile.rue => 'pages/user/profile'
+    def derive_template_name(file_path)
+      templates_pathname = Pathname.new(@templates_dir)
+      file_pathname = Pathname.new(file_path)
+      relative_path = file_pathname.relative_path_from(templates_pathname)
+      relative_path.to_s.sub(/\.rue$/, '')
+    end
+  end
+end

data/lib/rhales/utils/schema_generator.rb

@@ -0,0 +1,194 @@
+# lib/rhales/schema_generator.rb
+#
+# frozen_string_literal: true
+
+require 'open3'
+require 'tempfile'
+require 'fileutils'
+require_relative 'schema_extractor'
+require_relative 'json_serializer'
+
+module Rhales
+  # Generates JSON Schemas from Zod schemas using TypeScript execution
+  #
+  # This class uses pnpm exec tsx to execute Zod schema code and convert it
+  # to JSON Schema format. The generated schemas are saved to disk for use
+  # by the validation middleware.
+  #
+  # Usage:
+  #   generator = SchemaGenerator.new(
+  #     templates_dir: './templates',
+  #     output_dir: './public/schemas'
+  #   )
+  #   results = generator.generate_all
+  class SchemaGenerator
+    class GenerationError < StandardError; end
+
+    attr_reader :templates_dir, :output_dir
+
+    # @param templates_dir [String] Directory containing .rue files
+    # @param output_dir [String] Directory to save generated JSON schemas
+    #   Defaults to './public/schemas' (implementing project's public directory)
+    def initialize(templates_dir:, output_dir: nil)
+      @templates_dir = File.expand_path(templates_dir)
+
+      # Smart default: place schemas in public/schemas relative to current working directory
+      # This ensures schemas are generated in the implementing project, not the gem directory
+      @output_dir = if output_dir
+        File.expand_path(output_dir)
+      else
+        # Default to public/schemas in current working directory
+        File.expand_path('./public/schemas')
+      end
+
+      validate_setup!
+      ensure_output_directory!
+    end
+
+    # Generate JSON Schemas for all templates with <schema> sections
+    #
+    # @return [Hash] Generation results with stats
+    def generate_all
+      extractor = SchemaExtractor.new(@templates_dir)
+      schemas = extractor.extract_all
+
+      if schemas.empty?
+        return {
+          success: true,
+          generated: 0,
+          failed: 0,
+          message: 'No schemas found in templates'
+        }
+      end
+
+      results = {
+        success: true,
+        generated: 0,
+        failed: 0,
+        errors: []
+      }
+
+      schemas.each do |schema_info|
+        begin
+          generate_schema(schema_info)
+          results[:generated] += 1
+          puts "✓ Generated schema for: #{schema_info[:template_name]}"
+        rescue => e
+          results[:failed] += 1
+          results[:success] = false
+          error_msg = "Failed to generate schema for #{schema_info[:template_name]}: #{e.message}"
+          results[:errors] << error_msg
+          warn error_msg
+        end
+      end
+
+      results
+    end
+
+    # Generate JSON Schema for a single template
+    #
+    # @param schema_info [Hash] Schema information from SchemaExtractor
+    # @return [Hash] Generated JSON Schema
+    def generate_schema(schema_info)
+      # Create temp file in project directory so Node.js can resolve modules
+      temp_dir = File.join(Dir.pwd, 'tmp')
+      FileUtils.mkdir_p(temp_dir) unless Dir.exist?(temp_dir)
+
+      temp_file = Tempfile.new(['schema', '.mts'], temp_dir)
+
+      begin
+        # Write TypeScript script
+        temp_file.write(build_typescript_script(schema_info))
+        temp_file.close
+
+        # Execute with tsx via pnpm
+        stdout, stderr, status = Open3.capture3('pnpm', 'exec', 'tsx', temp_file.path)
+
+        unless status.success?
+          raise GenerationError, "TypeScript execution failed: #{stderr}"
+        end
+
+        # Parse JSON Schema from stdout
+        json_schema = JSONSerializer.parse(stdout)
+
+        # Save to disk
+        save_schema(schema_info[:template_name], json_schema)
+
+        json_schema
+      ensure
+        temp_file.unlink if temp_file
+      end
+    end
+
+    private
+
+    def build_typescript_script(schema_info)
+      # Escape single quotes in template name for TypeScript string
+      safe_name = schema_info[:template_name].gsub("'", "\\'")
+
+      <<~TYPESCRIPT
+        // Auto-generated schema generator for #{safe_name}
+        import { z } from 'zod/v4';
+
+        // Schema code from .rue template
+        #{schema_info[:schema_code].strip}
+
+        // Generate JSON Schema
+        try {
+          const jsonSchema = z.toJSONSchema(schema, {
+            target: 'draft-2020-12',
+            unrepresentable: 'any',
+            cycles: 'ref',
+            reused: 'inline',
+          });
+
+          // Add metadata
+          const schemaWithMeta = {
+            $schema: 'https://json-schema.org/draft/2020-12/schema',
+            $id: `https://rhales.dev/schemas/#{safe_name}.json`,
+            title: '#{safe_name}',
+            description: 'Schema for #{safe_name} template',
+            ...jsonSchema,
+          };
+
+          // Output JSON to stdout
+          console.log(JSON.stringify(schemaWithMeta, null, 2));
+        } catch (error) {
+          console.error('Schema generation error:', error.message);
+          process.exit(1);
+        }
+      TYPESCRIPT
+    end
+
+    def save_schema(template_name, json_schema)
+      # Create subdirectories if template name contains paths
+      schema_file = File.join(@output_dir, "#{template_name}.json")
+      schema_dir = File.dirname(schema_file)
+      FileUtils.mkdir_p(schema_dir) unless File.directory?(schema_dir)
+
+      File.write(schema_file, JSONSerializer.dump(json_schema))
+    end
+
+    def validate_setup!
+      unless File.directory?(@templates_dir)
+        raise GenerationError, "Templates directory does not exist: #{@templates_dir}"
+      end
+
+      # Check pnpm is available
+      stdout, stderr, status = Open3.capture3('pnpm', '--version')
+      unless status.success?
+        raise GenerationError, "pnpm not found. Install pnpm to generate schemas: npm install -g pnpm"
+      end
+
+      # Check tsx is available (will be installed by pnpm if needed)
+      stdout, stderr, status = Open3.capture3('pnpm', 'exec', 'tsx', '--version')
+      unless status.success?
+        raise GenerationError, "tsx not found. Run: pnpm install tsx --save-dev"
+      end
+    end
+
+    def ensure_output_directory!
+      FileUtils.mkdir_p(@output_dir) unless File.directory?(@output_dir)
+    end
+  end
+end

data/lib/rhales/utils.rb

@@ -0,0 +1,40 @@
+# lib/rhales/utils.rb
+#
+# frozen_string_literal: true
+
+require 'pathname'
+
+module Rhales
+  module Utils
+    # Utility modules and classes
+
+    # @return [Time] Current time in UTC
+    def now
+      Time.now.utc
+    end
+
+    # Returns the current time in microseconds.
+    # This is used to measure the duration of Database commands.
+    #
+    # Alias: now_in_microseconds
+    #
+    # @return [Integer] The current time in microseconds.
+    def now_in_μs
+      Process.clock_gettime(Process::CLOCK_MONOTONIC, :microsecond)
+    end
+    alias now_in_microseconds now_in_μs
+
+    # @param filepath [String, nil] The file path to prettify
+    # @return [String, nil] The expanded absolute path, or nil if input is
+    def pretty_path(filepath)
+      return nil if filepath.nil?
+
+      Pathname.new(filepath).expand_path.to_s
+    end
+  end
+end
+
+require_relative 'utils/json_serializer'
+require_relative 'utils/schema_generator'
+require_relative 'utils/schema_extractor'
+require_relative 'utils/logging_helpers'

data/lib/rhales/version.rb

@@ -1,8 +1,10 @@
 # lib/rhales/version.rb
+#
+# frozen_string_literal: true
 
 module Rhales
   # Version information for the RSFC gem
   unless defined?(Rhales::VERSION)
-    VERSION = '0.4.0'
+    VERSION = '0.5.3'
   end
 end

data/lib/rhales.rb

@@ -1,26 +1,25 @@
 # lib/rhales.rb
+#
+# frozen_string_literal: true
+
+require 'logger'
 
+# Core framework files
 require_relative 'rhales/version'
-require_relative 'rhales/errors'
 require_relative 'rhales/configuration'
-require_relative 'rhales/adapters/base_auth'
-require_relative 'rhales/adapters/base_session'
-require_relative 'rhales/context'
-require_relative 'rhales/rue_document'
-require_relative 'rhales/parsers/handlebars_parser'
-require_relative 'rhales/parsers/rue_format_parser'
-require_relative 'rhales/template_engine'
-require_relative 'rhales/hydrator'
-require_relative 'rhales/view_composition'
-require_relative 'rhales/hydration_data_aggregator'
-require_relative 'rhales/mount_point_detector'
-require_relative 'rhales/safe_injection_validator'
-require_relative 'rhales/earliest_injection_detector'
-require_relative 'rhales/link_based_injection_detector'
-require_relative 'rhales/hydration_injector'
-require_relative 'rhales/hydration_endpoint'
-require_relative 'rhales/refinements/require_refinements'
-require_relative 'rhales/view'
+require_relative 'rhales/errors'
+
+# Load components in dependency order
+require_relative 'rhales/adapters'
+require_relative 'rhales/parsers'
+require_relative 'rhales/utils'
+
+# Security (depends on utils)
+require_relative 'rhales/security/csp'
+require_relative 'rhales/core'
+require_relative 'rhales/hydration'
+require_relative 'rhales/integrations'
+require_relative 'rhales/middleware'
 
 # Ruby Single File Components (RSFC)
 #
@@ -34,6 +33,14 @@ require_relative 'rhales/view'
 # - Pluggable authentication and session adapters
 # - Security-first design with XSS protection and CSP support
 #
+# Modular Loading:
+#   require 'rhales'           # Loads everything (default)
+#   require 'rhales/core'      # Core engine only
+#   require 'rhales/hydration' # Hydration system only
+#   require 'rhales/parsers'   # Template parsers only
+#   require 'rhales/utils'     # Utilities only
+#   require 'rhales/all'       # Explicit full load
+#
 # Usage:
 #   Rhales.configure do |config|
 #     config.default_locale = 'en'
@@ -46,12 +53,22 @@ require_relative 'rhales/view'
 #     config.hydration.fallback_to_late = true
 #   end
 #
-#   view = Rhales::View.new(request, session, user)
+#   view = Rhales::View.new(request)
 #   html = view.render('my_component')
 module Rhales
+  extend Utils
+
+  class << self
+    attr_writer :logger
+
+    def logger
+      @logger ||= Logger.new($stdout)
+    end
+  end
+
   # Convenience method to create a view with props
-  def self.render(template_name, request: nil, session: nil, user: nil, locale: nil, **props)
-    view = View.new(request, session, user, locale, props: props)
+  def self.render(template_name, request: nil, locale: nil, **props)
+    view = View.new(request, locale, props: props)
     view.render(template_name)
   end
 
@@ -62,7 +79,7 @@ module Rhales
   end
 
   # Create context with props (for advanced usage)
-  def self.create_context(request: nil, session: nil, user: nil, locale: nil, **props)
-    Context.for_view(request, session, user, locale, **props)
+  def self.create_context(request: nil, locale: nil, **props)
+    Context.for_view(request, locale, **props)
   end
 end

data/lib/tasks/rhales_schema.rake

@@ -0,0 +1,197 @@
+# lib/tasks/rhales_schema.rake
+
+namespace :rhales do
+  namespace :schema do
+    desc 'Generate JSON Schemas from .rue template files'
+    task :generate do
+      require 'rhales'
+
+      # Default to current working directory (implementing project)
+      templates_dir = ENV.fetch('TEMPLATES_DIR', './templates')
+      output_dir = ENV.fetch('OUTPUT_DIR', './public/schemas')
+
+      puts "Schema Generation"
+      puts "=" * 60
+      puts "Templates: #{templates_dir}"
+      puts "Output: #{output_dir}"
+      puts "Zod: (using pnpm exec tsx)"
+      puts
+
+      # Validate templates directory exists
+      unless Dir.exist?(templates_dir)
+        puts "⚠️  Templates directory not found: #{templates_dir}"
+        puts
+        puts "Usage:"
+        puts "  rake rhales:schema:generate TEMPLATES_DIR=./templates OUTPUT_DIR=./public/schemas"
+        puts
+        puts "Or from project root where templates/ exists:"
+        puts "  rake rhales:schema:generate"
+        exit 1
+      end
+
+      # Extract schemas
+      extractor = Rhales::SchemaExtractor.new(templates_dir)
+      schemas = extractor.extract_all
+
+      if schemas.empty?
+        puts "⚠️  No schema sections found in templates"
+        puts
+        puts "Make sure your .rue files have <schema> sections:"
+        puts "  <schema lang=\"js-zod\" window=\"appData\">"
+        puts "  const schema = z.object({ ... });"
+        puts "  </schema>"
+        exit 0
+      end
+
+      puts "Found #{schemas.size} schema section(s):"
+      schemas.each do |schema|
+        puts "  - #{schema[:template_name]} (#{schema[:lang]})"
+      end
+      puts
+
+      # Generate JSON Schemas
+      generator = Rhales::SchemaGenerator.new(
+        templates_dir: templates_dir,
+        output_dir: output_dir
+      )
+
+      puts "Generating JSON Schemas..."
+      results = generator.generate_all
+
+      # Report results
+      puts
+      puts "Results:"
+      puts "-" * 60
+
+      generated_count = results[:generated]
+      failed_count = results[:failed]
+
+      if results[:success]
+        puts "✓ Successfully generated #{generated_count} schema(s)"
+        puts "✓ Output directory: #{output_dir}"
+      else
+        puts "✗ Generation failed with #{failed_count} error(s)"
+        results[:errors].each do |error|
+          puts "  - #{error}"
+        end
+      end
+
+      puts
+
+      exit(results[:success] ? 0 : 1)
+    end
+
+    desc 'Validate existing JSON Schemas'
+    task :validate do
+      require 'rhales'
+      require 'json'
+      require 'json_schemer'
+
+      # Default to current working directory
+      schemas_dir = ENV.fetch('OUTPUT_DIR', './public/schemas')
+
+      unless Dir.exist?(schemas_dir)
+        puts "⚠️  Schemas directory not found: #{schemas_dir}"
+        puts
+        puts "Generate schemas first:"
+        puts "  rake rhales:schema:generate"
+        exit 1
+      end
+
+      schema_files = Dir.glob("#{schemas_dir}/**/*.json")
+
+      if schema_files.empty?
+        puts "⚠️  No schema files found in #{schemas_dir}"
+        puts
+        puts "Generate schemas first:"
+        puts "  rake rhales:schema:generate"
+        exit 1
+      end
+
+      puts "Validating #{schema_files.size} schema file(s) in #{schemas_dir}..."
+      puts
+
+      errors = []
+
+      schema_files.each do |file|
+        relative_path = file.sub("#{schemas_dir}/", '')
+
+        begin
+          schema = JSON.parse(File.read(file))
+
+          # Validate against JSON Schema meta-schema
+          unless schema.is_a?(Hash)
+            errors << "#{relative_path}: Not a valid object"
+            next
+          end
+
+          # Use JSONSchemer to validate against the meta-schema
+          meta_schema = JSONSchemer.schema(
+            {
+              '$schema' => 'https://json-schema.org/draft/2020-12/schema'
+            }
+          )
+
+          validation_errors = meta_schema.validate(schema).to_a
+
+          if validation_errors.any?
+            validation_errors.each do |error|
+              errors << "#{relative_path}: #{error['type']} at #{error['data_pointer']}"
+            end
+          else
+            puts "✓ #{relative_path}"
+          end
+        rescue JSON::ParserError => e
+          errors << "#{relative_path}: Invalid JSON - #{e.message}"
+        rescue => e
+          errors << "#{relative_path}: #{e.message}"
+        end
+      end
+
+      puts
+
+      if errors.any?
+        puts "Errors:"
+        errors.each { |err| puts "  ✗ #{err}" }
+        exit 1
+      else
+        puts "All schemas valid ✓"
+      end
+    end
+
+    desc 'Show statistics about schema sections'
+    task :stats do
+      require 'rhales'
+
+      # Default to current working directory
+      templates_dir = ENV.fetch('TEMPLATES_DIR', './templates')
+
+      unless Dir.exist?(templates_dir)
+        puts "⚠️  Templates directory not found: #{templates_dir}"
+        puts
+        puts "Usage:"
+        puts "  rake rhales:schema:stats TEMPLATES_DIR=./templates"
+        exit 1
+      end
+
+      extractor = Rhales::SchemaExtractor.new(templates_dir)
+      stats = extractor.schema_stats
+
+      puts "Schema Statistics"
+      puts "=" * 60
+      puts "Templates directory: #{templates_dir}"
+      puts
+      puts "Total .rue files: #{stats[:total_files]}"
+      puts "Files with <schema>: #{stats[:files_with_schemas]}"
+      puts "Files without <schema>: #{stats[:files_without_schemas]}"
+      puts
+
+      if stats[:schemas_by_lang].any?
+        puts "By language:"
+        stats[:schemas_by_lang].each do |lang, count|
+          puts "  #{lang}: #{count}"
+        end
+      end
+    end
+  end
+end

data/package.json

@@ -0,0 +1,10 @@
+{
+  "type": "module",
+  "dependencies": {
+    "zod": "^4.1.12"
+  },
+  "devDependencies": {
+    "@prettier/plugin-ruby": "^4.0.4",
+    "tsx": "^4.20.6"
+  }
+}