RubyGems - tina4ruby - Versions diffs - 3.0.0 → 3.9.2 - Mend

tina4ruby 3.0.0 → 3.9.2

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (41) hide show

checksums.yaml +4 -4
data/README.md +120 -32
data/lib/tina4/auth.rb +137 -27
data/lib/tina4/auto_crud.rb +55 -3
data/lib/tina4/cli.rb +228 -28
data/lib/tina4/cors.rb +1 -1
data/lib/tina4/database.rb +230 -26
data/lib/tina4/database_result.rb +122 -8
data/lib/tina4/dev_mailbox.rb +1 -1
data/lib/tina4/env.rb +1 -1
data/lib/tina4/frond.rb +314 -7
data/lib/tina4/gallery/queue/meta.json +1 -1
data/lib/tina4/gallery/queue/src/routes/api/gallery_queue.rb +314 -16
data/lib/tina4/localization.rb +1 -1
data/lib/tina4/messenger.rb +111 -33
data/lib/tina4/middleware.rb +349 -1
data/lib/tina4/migration.rb +132 -11
data/lib/tina4/orm.rb +149 -18
data/lib/tina4/public/js/tina4-dev-admin.min.js +1 -1
data/lib/tina4/public/js/tina4js.min.js +47 -0
data/lib/tina4/query_builder.rb +374 -0
data/lib/tina4/queue.rb +219 -61
data/lib/tina4/queue_backends/lite_backend.rb +42 -7
data/lib/tina4/queue_backends/mongo_backend.rb +126 -0
data/lib/tina4/rack_app.rb +200 -11
data/lib/tina4/request.rb +14 -1
data/lib/tina4/response.rb +26 -0
data/lib/tina4/response_cache.rb +446 -29
data/lib/tina4/router.rb +127 -0
data/lib/tina4/service_runner.rb +1 -1
data/lib/tina4/session.rb +6 -1
data/lib/tina4/session_handlers/database_handler.rb +66 -0
data/lib/tina4/swagger.rb +1 -1
data/lib/tina4/templates/errors/404.twig +2 -2
data/lib/tina4/templates/errors/500.twig +1 -1
data/lib/tina4/validator.rb +174 -0
data/lib/tina4/version.rb +1 -1
data/lib/tina4/websocket.rb +23 -4
data/lib/tina4/websocket_backplane.rb +118 -0
data/lib/tina4.rb +126 -5
metadata +40 -3

data/lib/tina4/service_runner.rb CHANGED Viewed

@@ -171,7 +171,7 @@ module Tina4
       def run_loop(name, handler, options, ctx)
         max_retries = options.fetch(:max_retries, 3)
-        sleep_interval = (ENV["TINA4_SERVICE_SLEEP"] || 1).to_f
+        sleep_interval = (ENV["TINA4_SERVICE_SLEEP"] || 5).to_i.to_f
         if options[:daemon]
           run_daemon(name, handler, options, ctx, max_retries)

data/lib/tina4/session.rb CHANGED Viewed

@@ -108,7 +108,8 @@ module Tina4
     end
     def cookie_header
-      "#{@options[:cookie_name]}=#{@id}; Path=/; HttpOnly; SameSite=Lax; Max-Age=#{@options[:max_age]}"
+      samesite = ENV["TINA4_SESSION_SAMESITE"] || "Lax"
+      "#{@options[:cookie_name]}=#{@id}; Path=/; HttpOnly; SameSite=#{samesite}; Max-Age=#{@options[:max_age]}"
     end
     private
@@ -135,6 +136,10 @@ module Tina4
         Tina4::SessionHandlers::RedisHandler.new(@options[:handler_options])
       when :mongo, :mongodb
         Tina4::SessionHandlers::MongoHandler.new(@options[:handler_options])
+      when :valkey
+        Tina4::SessionHandlers::ValkeyHandler.new(@options[:handler_options])
+      when :database, :db
+        Tina4::SessionHandlers::DatabaseHandler.new(@options[:handler_options])
       else
         Tina4::SessionHandlers::FileHandler.new(@options[:handler_options])
       end

data/lib/tina4/session_handlers/database_handler.rb ADDED Viewed

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+require "json"
+module Tina4
+  module SessionHandlers
+    class DatabaseHandler
+      TABLE_NAME = "tina4_session"
+      CREATE_TABLE_SQL = <<~SQL
+        CREATE TABLE IF NOT EXISTS #{TABLE_NAME} (
+            session_id VARCHAR(255) PRIMARY KEY,
+            data TEXT NOT NULL,
+            expires_at REAL NOT NULL
+        )
+      SQL
+      def initialize(options = {})
+        @ttl = options[:ttl] || 86400
+        @db = options[:db] || Tina4::Database.new(ENV["DATABASE_URL"])
+        ensure_table
+      end
+      def read(session_id)
+        row = @db.fetch_one("SELECT data, expires_at FROM #{TABLE_NAME} WHERE session_id = ?", [session_id])
+        return nil unless row
+        expires_at = row["expires_at"].to_f
+        if expires_at > 0 && expires_at < Time.now.to_f
+          destroy(session_id)
+          return nil
+        end
+        JSON.parse(row["data"])
+      rescue JSON::ParserError
+        nil
+      end
+      def write(session_id, data)
+        expires_at = @ttl > 0 ? Time.now.to_f + @ttl : 0.0
+        json_data = JSON.generate(data)
+        existing = @db.fetch_one("SELECT session_id FROM #{TABLE_NAME} WHERE session_id = ?", [session_id])
+        if existing
+          @db.execute("UPDATE #{TABLE_NAME} SET data = ?, expires_at = ? WHERE session_id = ?", [json_data, expires_at, session_id])
+        else
+          @db.execute("INSERT INTO #{TABLE_NAME} (session_id, data, expires_at) VALUES (?, ?, ?)", [session_id, json_data, expires_at])
+        end
+      end
+      def destroy(session_id)
+        @db.execute("DELETE FROM #{TABLE_NAME} WHERE session_id = ?", [session_id])
+      end
+      def cleanup
+        @db.execute("DELETE FROM #{TABLE_NAME} WHERE expires_at > 0 AND expires_at < ?", [Time.now.to_f])
+      end
+      private
+      def ensure_table
+        @db.execute(CREATE_TABLE_SQL)
+      end
+    end
+  end
+end

data/lib/tina4/swagger.rb CHANGED Viewed

@@ -18,7 +18,7 @@ module Tina4
         {
           "openapi" => "3.0.3",
           "info" => {
-            "title" => ENV["PROJECT_NAME"] || "Tina4 Ruby API",
+            "title" => ENV["SWAGGER_TITLE"] || ENV["PROJECT_NAME"] || "Tina4 API",
             "version" => ENV["VERSION"] || Tina4::VERSION,
             "description" => "Auto-generated API documentation"
           },

data/lib/tina4/templates/errors/404.twig CHANGED Viewed

@@ -3,7 +3,7 @@
 <head>
 <meta charset="utf-8">
 <meta name="viewport" content="width=device-width, initial-scale=1">
-<title>404 — Not Found</title>
+<title>404 - Not Found</title>
 <style>
 * { box-sizing: border-box; margin: 0; padding: 0; }
 body { font-family: system-ui, -apple-system, sans-serif; background: #0f172a; color: #e2e8f0; min-height: 100vh; display: flex; align-items: center; justify-content: center; }
@@ -20,7 +20,7 @@ body { font-family: system-ui, -apple-system, sans-serif; background: #0f172a; c
 <div class="error-card">
     <div class="error-code">404</div>
     <div class="error-title">Page Not Found</div>
-    <div class="error-msg">The page you're looking for doesn't exist or has been moved. Check the URL and try again.</div>
+    <div class="error-msg">The page you are looking for does not exist or has been moved. Check the URL and try again.</div>
     <div class="error-path">{{ path }}</div>
     <br>
     <a href="/" class="error-home">Go Home</a>

data/lib/tina4/templates/errors/500.twig CHANGED Viewed

@@ -3,7 +3,7 @@
 <head>
 <meta charset="utf-8">
 <meta name="viewport" content="width=device-width, initial-scale=1">
-<title>500 — Server Error</title>
+<title>500 - Server Error</title>
 <style>
 * { box-sizing: border-box; margin: 0; padding: 0; }
 body { font-family: system-ui, -apple-system, sans-serif; background: #0f172a; color: #e2e8f0; min-height: 100vh; display: flex; align-items: center; justify-content: center; }

data/lib/tina4/validator.rb ADDED Viewed

@@ -0,0 +1,174 @@
+# frozen_string_literal: true
+module Tina4
+  # Request body validator with chainable rules.
+  #
+  # Usage:
+  #   validator = Tina4::Validator.new(request.body)
+  #   validator.required("name", "email")
+  #            .email("email")
+  #            .min_length("name", 2)
+  #            .max_length("name", 100)
+  #            .integer("age")
+  #            .min("age", 0)
+  #            .max("age", 150)
+  #            .in_list("role", ["admin", "user", "guest"])
+  #            .regex("phone", /^\+?[\d\s\-]+$/)
+  #
+  #   unless validator.is_valid?
+  #     return response.error("VALIDATION_FAILED", validator.errors.first[:message], 400)
+  #   end
+  #
+  class Validator
+    attr_reader :validation_errors
+    EMAIL_REGEX = /\A[a-zA-Z0-9._%+\-]+@[a-zA-Z0-9.\-]+\.[a-zA-Z]{2,}\z/
+    def initialize(data = {})
+      @data = data.is_a?(Hash) ? data : {}
+      # Normalise keys to strings for consistent lookup
+      @data = @data.transform_keys(&:to_s) unless @data.empty?
+      @validation_errors = []
+    end
+    # Check that one or more fields are present and non-empty.
+    def required(*fields)
+      fields.each do |field|
+        key = field.to_s
+        value = @data[key]
+        if value.nil? || (value.is_a?(String) && value.strip.empty?)
+          @validation_errors << { field: key, message: "#{key} is required" }
+        end
+      end
+      self
+    end
+    # Check that a field contains a valid email address.
+    def email(field)
+      key = field.to_s
+      value = @data[key]
+      return self if value.nil?
+      unless value.is_a?(String) && value.match?(EMAIL_REGEX)
+        @validation_errors << { field: key, message: "#{key} must be a valid email address" }
+      end
+      self
+    end
+    # Check that a string field has at least +length+ characters.
+    def min_length(field, length)
+      key = field.to_s
+      value = @data[key]
+      return self if value.nil?
+      unless value.is_a?(String) && value.length >= length
+        @validation_errors << { field: key, message: "#{key} must be at least #{length} characters" }
+      end
+      self
+    end
+    # Check that a string field has at most +length+ characters.
+    def max_length(field, length)
+      key = field.to_s
+      value = @data[key]
+      return self if value.nil?
+      unless value.is_a?(String) && value.length <= length
+        @validation_errors << { field: key, message: "#{key} must be at most #{length} characters" }
+      end
+      self
+    end
+    # Check that a field is an integer (or can be parsed as one).
+    def integer(field)
+      key = field.to_s
+      value = @data[key]
+      return self if value.nil?
+      if value.is_a?(Integer)
+        return self
+      end
+      begin
+        Integer(value)
+      rescue ArgumentError, TypeError
+        @validation_errors << { field: key, message: "#{key} must be an integer" }
+      end
+      self
+    end
+    # Check that a numeric field is >= +minimum+.
+    def min(field, minimum)
+      key = field.to_s
+      value = @data[key]
+      return self if value.nil?
+      begin
+        num = Float(value)
+      rescue ArgumentError, TypeError
+        return self
+      end
+      if num < minimum
+        @validation_errors << { field: key, message: "#{key} must be at least #{minimum}" }
+      end
+      self
+    end
+    # Check that a numeric field is <= +maximum+.
+    def max(field, maximum)
+      key = field.to_s
+      value = @data[key]
+      return self if value.nil?
+      begin
+        num = Float(value)
+      rescue ArgumentError, TypeError
+        return self
+      end
+      if num > maximum
+        @validation_errors << { field: key, message: "#{key} must be at most #{maximum}" }
+      end
+      self
+    end
+    # Check that a field's value is one of the allowed values.
+    def in_list(field, allowed)
+      key = field.to_s
+      value = @data[key]
+      return self if value.nil?
+      unless allowed.include?(value)
+        @validation_errors << { field: key, message: "#{key} must be one of #{allowed}" }
+      end
+      self
+    end
+    # Check that a field matches a regular expression.
+    def regex(field, pattern)
+      key = field.to_s
+      value = @data[key]
+      return self if value.nil?
+      regexp = pattern.is_a?(Regexp) ? pattern : Regexp.new(pattern)
+      unless value.is_a?(String) && value.match?(regexp)
+        @validation_errors << { field: key, message: "#{key} does not match the required format" }
+      end
+      self
+    end
+    # Return the list of validation errors (empty if valid).
+    def errors
+      @validation_errors.dup
+    end
+    # Return true if no validation errors have been recorded.
+    def is_valid?
+      @validation_errors.empty?
+    end
+    # Alias for is_valid? (Ruby convention)
+    alias_method :valid?, :is_valid?
+  end
+end

data/lib/tina4/version.rb CHANGED Viewed

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 module Tina4
-  VERSION = "3.0.0"
+  VERSION = "3.9.2"
 end

data/lib/tina4/websocket.rb CHANGED Viewed

@@ -44,7 +44,8 @@ module Tina4
       socket.write(response)
       conn_id = SecureRandom.hex(16)
-      connection = WebSocketConnection.new(conn_id, socket)
+      ws_path = env["REQUEST_PATH"] || env["PATH_INFO"] || "/"
+      connection = WebSocketConnection.new(conn_id, socket, ws_server: self, path: ws_path)
       @connections[conn_id] = connection
       emit(:open, connection)
@@ -74,9 +75,10 @@ module Tina4
       end
     end
-    def broadcast(message, exclude: nil)
+    def broadcast(message, exclude: nil, path: nil)
       @connections.each do |id, conn|
         next if exclude && id == exclude
+        next if path && conn.path != path
         conn.send_text(message)
       end
     end
@@ -90,13 +92,28 @@ module Tina4
   class WebSocketConnection
     attr_reader :id
+    attr_accessor :params, :path
-    def initialize(id, socket)
+    def initialize(id, socket, ws_server: nil, path: "/")
       @id = id
       @socket = socket
+      @params = {}
+      @ws_server = ws_server
+      @path = path
     end
-    def send_text(message)
+    # Broadcast a message to all other connections on the same path
+    def broadcast(message, include_self: false)
+      return unless @ws_server
+      @ws_server.connections.each do |cid, conn|
+        next if !include_self && cid == @id
+        next if conn.path != @path
+        conn.send_text(message)
+      end
+    end
+    def send(message)
       data = message.encode("UTF-8")
       frame = build_frame(0x1, data)
       @socket.write(frame)
@@ -104,6 +121,8 @@ module Tina4
       # Connection closed
     end
+    alias_method :send_text, :send
     def send_pong(data)
       frame = build_frame(0xA, data || "")
       @socket.write(frame)

data/lib/tina4/websocket_backplane.rb ADDED Viewed

@@ -0,0 +1,118 @@
+# frozen_string_literal: true
+# WebSocket Backplane Abstraction for Tina4 Ruby.
+#
+# Enables broadcasting WebSocket messages across multiple server instances
+# using a shared pub/sub channel (e.g. Redis). Without a backplane configured,
+# broadcast() only reaches connections on the local process.
+#
+# Configuration via environment variables:
+#   TINA4_WS_BACKPLANE     — Backend type: "redis", "nats", or "" (default: none)
+#   TINA4_WS_BACKPLANE_URL — Connection string (default: redis://localhost:6379)
+#
+# Usage:
+#   backplane = Tina4::WebSocketBackplane.create
+#   if backplane
+#     backplane.subscribe("chat") { |msg| relay_to_local(msg) }
+#     backplane.publish("chat", '{"user":"A","text":"hello"}')
+#   end
+module Tina4
+  # Base backplane interface for scaling WebSocket broadcast across instances.
+  #
+  # Subclasses implement publish/subscribe over a shared message bus so that
+  # every server instance receives every broadcast, not just the originator.
+  class WebSocketBackplane
+    # Publish a message to all instances listening on +channel+.
+    def publish(channel, message)
+      raise NotImplementedError, "#{self.class}#publish not implemented"
+    end
+    # Subscribe to +channel+. The block is called with each incoming message.
+    # Runs in a background thread.
+    def subscribe(channel, &block)
+      raise NotImplementedError, "#{self.class}#subscribe not implemented"
+    end
+    # Stop listening on +channel+.
+    def unsubscribe(channel)
+      raise NotImplementedError, "#{self.class}#unsubscribe not implemented"
+    end
+    # Tear down connections and background threads.
+    def close
+      raise NotImplementedError, "#{self.class}#close not implemented"
+    end
+    # Factory that reads TINA4_WS_BACKPLANE and returns the appropriate
+    # backplane instance, or +nil+ if no backplane is configured.
+    #
+    # This keeps backplane usage entirely optional — callers simply check
+    # +if backplane+ before publishing.
+    def self.create(url: nil)
+      backend = ENV.fetch("TINA4_WS_BACKPLANE", "").strip.downcase
+      case backend
+      when "redis"
+        RedisBackplane.new(url: url)
+      when "nats"
+        raise NotImplementedError, "NATS backplane is on the roadmap but not yet implemented."
+      when ""
+        nil
+      else
+        raise ArgumentError, "Unknown TINA4_WS_BACKPLANE value: '#{backend}'"
+      end
+    end
+  end
+  # Redis pub/sub backplane.
+  #
+  # Requires the +redis+ gem (+gem install redis+). The require is deferred
+  # so the rest of Tina4 works fine without it installed — an error is raised
+  # only when this class is actually instantiated.
+  class RedisBackplane < WebSocketBackplane
+    def initialize(url: nil)
+      begin
+        require "redis"
+      rescue LoadError
+        raise LoadError,
+          "The 'redis' gem is required for RedisBackplane. " \
+          "Install it with: gem install redis"
+      end
+      @url = url || ENV.fetch("TINA4_WS_BACKPLANE_URL", "redis://localhost:6379")
+      @redis = Redis.new(url: @url)
+      @subscriber = Redis.new(url: @url)
+      @threads = {}
+      @running = true
+    end
+    def publish(channel, message)
+      @redis.publish(channel, message)
+    end
+    def subscribe(channel, &block)
+      @threads[channel] = Thread.new do
+        @subscriber.subscribe(channel) do |on|
+          on.message do |_chan, msg|
+            block.call(msg) if @running
+          end
+        end
+      end
+    end
+    def unsubscribe(channel)
+      @subscriber.unsubscribe(channel)
+      thread = @threads.delete(channel)
+      thread&.join(1)
+    end
+    def close
+      @running = false
+      @threads.each_value { |t| t.kill }
+      @threads.clear
+      @subscriber.close
+      @redis.close
+    end
+  end
+end

data/lib/tina4.rb CHANGED Viewed

@@ -22,6 +22,7 @@ require_relative "tina4/database"
 require_relative "tina4/database_result"
 require_relative "tina4/field_types"
 require_relative "tina4/orm"
+require_relative "tina4/query_builder"
 require_relative "tina4/migration"
 require_relative "tina4/auto_crud"
 require_relative "tina4/database/sqlite3_adapter"
@@ -63,7 +64,8 @@ module Tina4
     autoload :FileHandler,  File.expand_path("tina4/session_handlers/file_handler", __dir__)
     autoload :RedisHandler, File.expand_path("tina4/session_handlers/redis_handler", __dir__)
     autoload :MongoHandler,  File.expand_path("tina4/session_handlers/mongo_handler", __dir__)
-    autoload :ValkeyHandler, File.expand_path("tina4/session_handlers/valkey_handler", __dir__)
+    autoload :ValkeyHandler,   File.expand_path("tina4/session_handlers/valkey_handler", __dir__)
+    autoload :DatabaseHandler, File.expand_path("tina4/session_handlers/database_handler", __dir__)
   end
   # ── Lazy-loaded: queue backends ───────────────────────────────────────
@@ -71,6 +73,7 @@ module Tina4
     autoload :LiteBackend,     File.expand_path("tina4/queue_backends/lite_backend", __dir__)
     autoload :RabbitmqBackend, File.expand_path("tina4/queue_backends/rabbitmq_backend", __dir__)
     autoload :KafkaBackend,    File.expand_path("tina4/queue_backends/kafka_backend", __dir__)
+    autoload :MongoBackend,    File.expand_path("tina4/queue_backends/mongo_backend", __dir__)
   end
   # ── Lazy-loaded: web server ───────────────────────────────────────────
@@ -106,7 +109,7 @@ module Tina4
   class << self
     attr_accessor :root_dir, :database
-    def print_banner(host: "0.0.0.0", port: 7147)
+    def print_banner(host: "0.0.0.0", port: 7147, server_name: nil)
       is_tty = $stdout.respond_to?(:isatty) && $stdout.isatty
       color = is_tty ? "\e[31m" : ""
       reset = is_tty ? "\e[0m" : ""
@@ -115,10 +118,24 @@ module Tina4
       log_level = (ENV["TINA4_LOG_LEVEL"] || "[TINA4_LOG_ALL]").upcase
       display = (host == "0.0.0.0" || host == "::") ? "localhost" : host
+      # Auto-detect server name if not provided
+      if server_name.nil?
+        if is_debug
+          server_name = "WEBrick"
+        else
+          begin
+            require "puma"
+            server_name = "puma"
+          rescue LoadError
+            server_name = "WEBrick"
+          end
+        end
+      end
       puts "#{color}#{BANNER}#{reset}"
       puts "  Tina4 Ruby v#{VERSION} — This is not a framework"
       puts ""
-      puts "  Server:    http://#{display}:#{port}"
+      puts "  Server:    http://#{display}:#{port} (#{server_name})"
       puts "  Swagger:   http://localhost:#{port}/swagger"
       puts "  Dashboard: http://localhost:#{port}/__dev"
       puts "  Debug:     #{is_debug ? 'ON' : 'OFF'} (Log level: #{log_level})"
@@ -155,6 +172,104 @@ module Tina4
       Tina4::Log.info("Tina4 initialized successfully")
     end
+    # Initialize and start the web server.
+    # This is the primary entry point for app.rb files:
+    #   Tina4.initialize!(__dir__)
+    #   Tina4.run!
+    # Or combined: Tina4.run!(__dir__)
+    def find_available_port(start, max_tries = 10)
+      require "socket"
+      max_tries.times do |offset|
+        port = start + offset
+        begin
+          server = TCPServer.new("127.0.0.1", port)
+          server.close
+          return port
+        rescue Errno::EADDRINUSE, Errno::EACCES
+          next
+        end
+      end
+      start
+    end
+    def open_browser(url)
+      require "rbconfig"
+      Thread.new do
+        sleep 2
+        case RbConfig::CONFIG["host_os"]
+        when /darwin/i then system("open", url)
+        when /mswin|mingw/i then system("start", url)
+        else system("xdg-open", url)
+        end
+      end
+    end
+    def run!(root_dir = nil, port: nil, host: nil, debug: nil)
+      # Handle legacy call: run!(port: 7147) where root_dir receives the hash
+      if root_dir.is_a?(Hash)
+        port ||= root_dir[:port]
+        host ||= root_dir[:host]
+        debug = root_dir[:debug] if debug.nil? && root_dir.key?(:debug)
+        root_dir = nil
+      end
+      root_dir ||= Dir.pwd
+      ENV["PORT"] = port.to_s if port
+      ENV["HOST"] = host.to_s if host
+      ENV["TINA4_DEBUG"] = debug.to_s unless debug.nil?
+      initialize!(root_dir) unless @root_dir
+      host = ENV.fetch("HOST", ENV.fetch("TINA4_HOST", "0.0.0.0"))
+      port = ENV.fetch("PORT", ENV.fetch("TINA4_PORT", "7147")).to_i
+      actual_port = find_available_port(port)
+      if actual_port != port
+        Tina4::Log.info("Port #{port} in use, using #{actual_port}")
+        port = actual_port
+      end
+      display_host = (host == "0.0.0.0" || host == "::") ? "localhost" : host
+      url = "http://#{display_host}:#{port}"
+      app = Tina4::RackApp.new(root_dir: root_dir)
+      is_debug = Tina4::Env.truthy?(ENV["TINA4_DEBUG"])
+      # Try Puma first (production-grade), fall back to WEBrick
+      if !is_debug
+        begin
+          require "puma"
+          require "puma/configuration"
+          require "puma/launcher"
+          config = Puma::Configuration.new do |user_config|
+            user_config.bind "tcp://#{host}:#{port}"
+            user_config.app app
+            user_config.threads 0, 16
+            user_config.workers 0
+            user_config.environment "production"
+            user_config.log_requests false
+            user_config.quiet
+          end
+          Tina4::Log.info("Production server: puma")
+          Tina4::Shutdown.setup
+          open_browser(url)
+          launcher = Puma::Launcher.new(config)
+          launcher.run
+          return
+        rescue LoadError
+          # Puma not installed, fall through to WEBrick
+        end
+      end
+      Tina4::Log.info("Development server: WEBrick")
+      open_browser(url)
+      server = Tina4::WebServer.new(app, host: host, port: port)
+      server.start
+    end
     # DSL methods for route registration
     # GET is public by default (matching tina4_python behavior)
     # POST/PUT/PATCH/DELETE are secured by default — use auth: false to make public
@@ -225,6 +340,11 @@ module Tina4
       Tina4::Router.group(prefix, auth_handler: auth, &block)
     end
+    # WebSocket route registration
+    def websocket(path, &block)
+      Tina4::Router.websocket(path, &block)
+    end
     # Middleware hooks
     def before(pattern = nil, &block)
       Tina4::Middleware.before(pattern, &block)
@@ -294,8 +414,9 @@ module Tina4
     end
     def auto_discover(root_dir)
-      route_dirs = %w[routes src/routes src/api api]
-      route_dirs.each do |dir|
+      # src/ prefixed directories take priority over root-level ones
+      discover_dirs = %w[src/routes routes src/api api src/orm orm]
+      discover_dirs.each do |dir|
         full_dir = File.join(root_dir, dir)
         next unless Dir.exist?(full_dir)