tina4ruby 3.0.0 → 3.9.2

data/lib/tina4/cli.rb

@@ -5,7 +5,7 @@ require "fileutils"
 
 module Tina4
   class CLI
-    COMMANDS = %w[init start migrate seed seed:create test version routes console ai help].freeze
+    COMMANDS = %w[init start migrate migrate:status migrate:rollback seed seed:create test version routes console generate ai help].freeze
 
     def self.start(argv)
       new.run(argv)
@@ -17,12 +17,15 @@ module Tina4
       when "init"       then cmd_init(argv)
       when "start"      then cmd_start(argv)
       when "migrate"    then cmd_migrate(argv)
+      when "migrate:status" then cmd_migrate_status(argv)
+      when "migrate:rollback" then cmd_migrate_rollback(argv)
       when "seed"       then cmd_seed(argv)
       when "seed:create" then cmd_seed_create(argv)
       when "test"       then cmd_test(argv)
       when "version"    then cmd_version
       when "routes"     then cmd_routes
       when "console"    then cmd_console
+      when "generate"   then cmd_generate(argv)
       when "ai"         then cmd_ai(argv)
       when "help", "-h", "--help" then cmd_help
       else
@@ -97,37 +100,45 @@ module Tina4
 
       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
-      begin
-        require "puma"
-        require "puma/configuration"
-        require "puma/launcher"
-
-        puma_host = options[:host]
-        puma_port = options[:port]
-
-        config = Puma::Configuration.new do |user_config|
-          user_config.bind "tcp://#{puma_host}:#{puma_port}"
-          user_config.app app
-          user_config.threads 0, 16
-          user_config.workers 0
-          user_config.environment "development"
-          user_config.log_requests false
-          user_config.quiet
-        end
+      # In debug mode, always use WEBrick for dev toolbar/reload support
+      if !is_debug
+        begin
+          require "puma"
+          require "puma/configuration"
+          require "puma/launcher"
+
+          puma_host = options[:host]
+          puma_port = options[:port]
+
+          config = Puma::Configuration.new do |user_config|
+            user_config.bind "tcp://#{puma_host}:#{puma_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("Starting Puma server on http://#{puma_host}:#{puma_port}")
+          Tina4::Log.info("Production server: puma")
 
-        # Setup graceful shutdown (Puma manages its own signals, but we handle DB cleanup)
-        Tina4::Shutdown.setup
+          # Setup graceful shutdown (Puma manages its own signals, but we handle DB cleanup)
+          Tina4::Shutdown.setup
 
-        launcher = Puma::Launcher.new(config)
-        launcher.run
-      rescue LoadError
-        Tina4::Log.info("Puma not found, falling back to WEBrick")
-        server = Tina4::WebServer.new(app, host: options[:host], port: options[:port])
-        server.start
+          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")
+      server = Tina4::WebServer.new(app, host: options[:host], port: options[:port])
+      server.start
     end
 
     # ── migrate ───────────────────────────────────────────────────────────
@@ -171,6 +182,75 @@ module Tina4
       end
     end
 
+    # ── migrate:status ─────────────────────────────────────────────────────
+
+    def cmd_migrate_status(_argv)
+      require_relative "../tina4"
+      Tina4.initialize!(Dir.pwd)
+
+      db = Tina4.database
+      unless db
+        puts "No database configured. Set DATABASE_URL in your .env file."
+        return
+      end
+
+      migration = Tina4::Migration.new(db)
+      info = migration.status
+
+      puts "\nMigration Status"
+      puts "-" * 60
+
+      if info[:completed].any?
+        puts "\nCompleted:"
+        info[:completed].each { |name| puts "  [OK] #{name}" }
+      end
+
+      if info[:pending].any?
+        puts "\nPending:"
+        info[:pending].each { |name| puts "  [  ] #{name}" }
+      end
+
+      if info[:completed].empty? && info[:pending].empty?
+        puts "  No migrations found."
+      end
+
+      puts "-" * 60
+      puts "  Completed: #{info[:completed].length}  Pending: #{info[:pending].length}\n"
+    end
+
+    # ── migrate:rollback ───────────────────────────────────────────────────
+
+    def cmd_migrate_rollback(argv)
+      options = { steps: 1 }
+      parser = OptionParser.new do |opts|
+        opts.banner = "Usage: tina4ruby migrate:rollback [options]"
+        opts.on("-n", "--steps N", Integer, "Number of batches to rollback (default: 1)") { |v| options[:steps] = v }
+      end
+      parser.parse!(argv)
+
+      require_relative "../tina4"
+      Tina4.initialize!(Dir.pwd)
+
+      db = Tina4.database
+      unless db
+        puts "No database configured. Set DATABASE_URL in your .env file."
+        return
+      end
+
+      migration = Tina4::Migration.new(db)
+      results = migration.rollback(options[:steps])
+
+      if results.empty?
+        puts "Nothing to rollback."
+      else
+        results.each do |r|
+          status_icon = r[:status] == "rolled_back" ? "OK" : "FAIL"
+          puts "  [#{status_icon}] #{r[:name]}"
+        end
+        puts "Rolled back #{results.length} migration(s)."
+      end
+    end
+
     # ── seed ──────────────────────────────────────────────────────────────
 
     def cmd_seed(argv)
@@ -310,6 +390,123 @@ module Tina4
 
     # ── help ──────────────────────────────────────────────────────────────
 
+    # ── generate ────────────────────────────────────────────────────────
+
+    def cmd_generate(argv)
+      what = argv.shift
+      name = argv.shift
+      unless what && name
+        puts "Usage: tina4ruby generate <what> <name>"
+        puts "  Generators: model, route, migration, middleware"
+        exit 1
+      end
+
+      case what
+      when "model"    then generate_model(name)
+      when "route"    then generate_route(name)
+      when "migration" then generate_migration(name)
+      when "middleware" then generate_middleware(name)
+      else
+        puts "Unknown generator: #{what}"
+        puts "  Available: model, route, migration, middleware"
+        exit 1
+      end
+    end
+
+    def generate_model(name)
+      dir = "src/orm"
+      FileUtils.mkdir_p(dir)
+      snake = name.gsub(/([A-Z])/) { |m| ($~.begin(0) > 0 ? "_" : "") + m.downcase }
+      path = File.join(dir, "#{snake}.rb")
+      abort "  File already exists: #{path}" if File.exist?(path)
+      File.write(path, <<~RUBY)
+        class #{name} < Tina4::ORM
+          integer_field :id, primary_key: true, auto_increment: true
+          string_field :name
+          string_field :email
+        end
+      RUBY
+      puts "  Created #{path}"
+    end
+
+    def generate_route(name)
+      route_path = name.sub(%r{^/}, "")
+      dir = "src/routes/#{route_path}"
+      FileUtils.mkdir_p(dir)
+      path = dir.chomp("/") + ".rb"
+      abort "  File already exists: #{path}" if File.exist?(path)
+      File.write(path, <<~RUBY)
+        Tina4.get "/#{route_path}" do |request, response|
+          response.json(data: [])
+        end
+
+        Tina4.get "/#{route_path}/:id" do |request, response|
+          response.json(data: {})
+        end
+
+        Tina4.post "/#{route_path}" do |request, response|
+          response.json({ message: "created" }, 201)
+        end
+
+        Tina4.put "/#{route_path}/:id" do |request, response|
+          response.json(message: "updated")
+        end
+
+        Tina4.delete "/#{route_path}/:id" do |request, response|
+          response.json(message: "deleted")
+        end
+      RUBY
+      puts "  Created #{path}"
+    end
+
+    def generate_migration(name)
+      dir = "migrations"
+      FileUtils.mkdir_p(dir)
+      timestamp = Time.now.strftime("%Y%m%d%H%M%S")
+      table = name.sub(/^create_/, "")
+      table = if table.end_with?("s")
+                table
+              elsif table.end_with?("y")
+                table[0..-2] + "ies"
+              else
+                table + "s"
+              end
+      filename = "#{timestamp}_#{name}.sql"
+      path = File.join(dir, filename)
+      now = Time.now.strftime("%Y-%m-%d %H:%M:%S")
+      File.write(path, <<~SQL)
+        -- Migration: #{name}
+        -- Created: #{now}
+
+        CREATE TABLE #{table} (
+            id INTEGER PRIMARY KEY AUTOINCREMENT,
+            name TEXT NOT NULL,
+            email TEXT NOT NULL,
+            created_at DATETIME DEFAULT CURRENT_TIMESTAMP
+        );
+      SQL
+      puts "  Created #{path}"
+    end
+
+    def generate_middleware(name)
+      dir = "src/middleware"
+      FileUtils.mkdir_p(dir)
+      snake = name.gsub(/([A-Z])/) { |m| ($~.begin(0) > 0 ? "_" : "") + m.downcase }
+      path = File.join(dir, "#{snake}.rb")
+      abort "  File already exists: #{path}" if File.exist?(path)
+      File.write(path, <<~RUBY)
+        class #{name} < Tina4::Middleware
+          def process(request, response)
+            auth = request.headers["Authorization"]
+            return response.json({ error: "Unauthorized" }, 401) unless auth
+
+            nil
+          end
+        end
+      RUBY
+      puts "  Created #{path}"
+    end
+
     def cmd_help
       puts <<~HELP
         Tina4 Ruby CLI
@@ -320,12 +517,15 @@ module Tina4
           init [NAME]        Initialize a new Tina4 project
           start              Start the Tina4 web server
           migrate            Run database migrations
+          migrate:status     Show migration status (completed and pending)
+          migrate:rollback   Rollback the last batch of migrations
           seed               Run all seed files in seeds/
           seed:create NAME   Create a new seed file
           test               Run inline tests
           version            Show Tina4 version
           routes             List all registered routes
           console            Start an interactive console
+          generate <what> <name>  Generate scaffolding (model, route, migration, middleware)
           ai                 Detect AI tools and install context files
           help               Show this help message
 
@@ -355,7 +555,7 @@ module Tina4
     # ── shared helpers ────────────────────────────────────────────────────
 
     def load_routes(root_dir)
-      route_dirs = %w[routes src/routes src/api api]
+      route_dirs = %w[src/routes routes src/api api src/orm orm]
       route_dirs.each do |dir|
         route_dir = File.join(root_dir, dir)
         next unless Dir.exist?(route_dir)

data/lib/tina4/cors.rb

@@ -52,7 +52,7 @@ module Tina4
         {
           origins: ENV["TINA4_CORS_ORIGINS"] || "*",
           methods: ENV["TINA4_CORS_METHODS"] || "GET, POST, PUT, PATCH, DELETE, OPTIONS",
-          headers: ENV["TINA4_CORS_HEADERS"] || "Content-Type, Authorization, Accept",
+          headers: ENV["TINA4_CORS_HEADERS"] || "Content-Type,Authorization,X-Request-ID",
           max_age: ENV["TINA4_CORS_MAX_AGE"] || "86400",
           credentials: ENV["TINA4_CORS_CREDENTIALS"] || "false"
         }.freeze

data/lib/tina4/database.rb

@@ -1,10 +1,72 @@
 # frozen_string_literal: true
 require "json"
 require "uri"
+require "digest"
 
 module Tina4
+  # Thread-safe connection pool with round-robin rotation.
+  # Connections are created lazily on first use.
+  class ConnectionPool
+    attr_reader :size
+
+    def initialize(pool_size, driver_factory:, connection_string:, username: nil, password: nil)
+      @pool_size = pool_size
+      @driver_factory = driver_factory
+      @connection_string = connection_string
+      @username = username
+      @password = password
+      @drivers = Array.new(pool_size)  # nil slots — lazy creation
+      @index = 0
+      @mutex = Mutex.new
+    end
+
+    # Get the next driver via round-robin. Thread-safe.
+    def checkout
+      @mutex.synchronize do
+        idx = @index
+        @index = (@index + 1) % @pool_size
+
+        if @drivers[idx].nil?
+          driver = @driver_factory.call
+          driver.connect(@connection_string, username: @username, password: @password)
+          @drivers[idx] = driver
+        end
+
+        @drivers[idx]
+      end
+    end
+
+    # Return a driver to the pool. Currently a no-op for round-robin.
+    def checkin(_driver)
+      # no-op
+    end
+
+    # Close all active connections.
+    def close_all
+      @mutex.synchronize do
+        @drivers.each_with_index do |driver, i|
+          if driver
+            driver.close rescue nil
+            @drivers[i] = nil
+          end
+        end
+      end
+    end
+
+    # Number of connections that have been created.
+    def active_count
+      @mutex.synchronize do
+        @drivers.count { |d| !d.nil? }
+      end
+    end
+
+    def size
+      @pool_size
+    end
+  end
+
   class Database
-    attr_reader :driver, :driver_name, :connected
+    attr_reader :driver, :driver_name, :connected, :pool
 
     DRIVERS = {
       "sqlite" => "Tina4::Drivers::SqliteDriver",
@@ -17,19 +79,50 @@ module Tina4
       "firebird" => "Tina4::Drivers::FirebirdDriver"
     }.freeze
 
-    def initialize(connection_string = nil, username: nil, password: nil, driver_name: nil)
+    def initialize(connection_string = nil, username: nil, password: nil, driver_name: nil, pool: 0)
       @connection_string = connection_string || ENV["DATABASE_URL"]
       @username = username || ENV["DATABASE_USERNAME"]
       @password = password || ENV["DATABASE_PASSWORD"]
       @driver_name = driver_name || detect_driver(@connection_string)
-      @driver = create_driver
+      @pool_size = pool  # 0 = single connection, N>0 = N pooled connections
       @connected = false
-      connect
+
+      # Query cache — off by default, opt-in via TINA4_DB_CACHE=true
+      @cache_enabled = truthy?(ENV["TINA4_DB_CACHE"])
+      @cache_ttl = (ENV["TINA4_DB_CACHE_TTL"] || "30").to_i
+      @query_cache = {}  # key => { expires_at:, value: }
+      @cache_hits = 0
+      @cache_misses = 0
+      @cache_mutex = Mutex.new
+
+      if @pool_size > 0
+        # Pooled mode — create a ConnectionPool with lazy driver creation
+        @pool = ConnectionPool.new(
+          @pool_size,
+          driver_factory: method(:create_driver),
+          connection_string: @connection_string,
+          username: @username,
+          password: @password
+        )
+        @driver = nil
+        @connected = true
+      else
+        # Single-connection mode — current behavior
+        @pool = nil
+        @driver = create_driver
+        connect
+      end
     end
 
     def connect
       @driver.connect(@connection_string, username: @username, password: @password)
       @connected = true
+
+      # Enable autocommit if TINA4_AUTOCOMMIT env var is set
+      if truthy?(ENV["TINA4_AUTOCOMMIT"]) && @driver.respond_to?(:autocommit=)
+        @driver.autocommit = true
+      end
+
       Tina4::Log.info("Database connected: #{@driver_name}")
     rescue => e
       Tina4::Log.error("Database connection failed: #{e.message}")
@@ -37,53 +130,129 @@ module Tina4
     end
 
     def close
-      @driver.close if @connected
+      if @pool
+        @pool.close_all
+      elsif @driver && @connected
+        @driver.close
+      end
       @connected = false
     end
 
-    def fetch(sql, params = [], limit: nil, skip: nil)
+    # Get the current driver — from pool (round-robin) or single connection.
+    def current_driver
+      if @pool
+        @pool.checkout
+      else
+        @driver
+      end
+    end
+
+    # ── Query Cache ──────────────────────────────────────────────
+
+    def cache_stats
+      @cache_mutex.synchronize do
+        {
+          enabled: @cache_enabled,
+          hits: @cache_hits,
+          misses: @cache_misses,
+          size: @query_cache.size,
+          ttl: @cache_ttl
+        }
+      end
+    end
+
+    def cache_clear
+      @cache_mutex.synchronize do
+        @query_cache.clear
+        @cache_hits = 0
+        @cache_misses = 0
+      end
+    end
+
+    def fetch(sql, params = [], limit: nil, offset: nil)
+      offset ||= 0
+      drv = current_driver
+
       effective_sql = sql
       if limit
-        effective_sql = @driver.apply_limit(effective_sql, limit, skip || 0)
+        effective_sql = drv.apply_limit(effective_sql, limit, offset)
+      end
+
+      if @cache_enabled
+        key = cache_key(effective_sql, params)
+        cached = cache_get(key)
+        if cached
+          @cache_mutex.synchronize { @cache_hits += 1 }
+          return cached
+        end
+        result = drv.execute_query(effective_sql, params)
+        result = Tina4::DatabaseResult.new(result, sql: effective_sql, db: self)
+        cache_set(key, result)
+        @cache_mutex.synchronize { @cache_misses += 1 }
+        return result
       end
-      rows = @driver.execute_query(effective_sql, params)
-      Tina4::DatabaseResult.new(rows, sql: effective_sql)
+
+      rows = drv.execute_query(effective_sql, params)
+      Tina4::DatabaseResult.new(rows, sql: effective_sql, db: self)
     end
 
     def fetch_one(sql, params = [])
+      if @cache_enabled
+        key = cache_key(sql + ":ONE", params)
+        cached = cache_get(key)
+        if cached
+          @cache_mutex.synchronize { @cache_hits += 1 }
+          return cached
+        end
+        result = fetch(sql, params, limit: 1)
+        value = result.first
+        cache_set(key, value)
+        @cache_mutex.synchronize { @cache_misses += 1 }
+        return value
+      end
+
       result = fetch(sql, params, limit: 1)
       result.first
     end
 
     def insert(table, data)
+      cache_invalidate if @cache_enabled
+      drv = current_driver
+
       # List of hashes — batch insert
       if data.is_a?(Array)
         return { success: true, affected_rows: 0 } if data.empty?
         keys = data.first.keys.map(&:to_s)
-        placeholders = @driver.placeholders(keys.length)
+        placeholders = drv.placeholders(keys.length)
         sql = "INSERT INTO #{table} (#{keys.join(', ')}) VALUES (#{placeholders})"
         params_list = data.map { |row| keys.map { |k| row[k.to_sym] || row[k] } }
         return execute_many(sql, params_list)
       end
 
       columns = data.keys.map(&:to_s)
-      placeholders = @driver.placeholders(columns.length)
+      placeholders = drv.placeholders(columns.length)
       sql = "INSERT INTO #{table} (#{columns.join(', ')}) VALUES (#{placeholders})"
-      @driver.execute(sql, data.values)
-      { success: true, last_id: @driver.last_insert_id }
+      drv.execute(sql, data.values)
+      { success: true, last_id: drv.last_insert_id }
     end
 
     def update(table, data, filter = {})
-      set_parts = data.keys.map { |k| "#{k} = #{@driver.placeholder}" }
-      where_parts = filter.keys.map { |k| "#{k} = #{@driver.placeholder}" }
+      cache_invalidate if @cache_enabled
+      drv = current_driver
+
+      set_parts = data.keys.map { |k| "#{k} = #{drv.placeholder}" }
+      where_parts = filter.keys.map { |k| "#{k} = #{drv.placeholder}" }
       sql = "UPDATE #{table} SET #{set_parts.join(', ')}"
       sql += " WHERE #{where_parts.join(' AND ')}" unless filter.empty?
       values = data.values + filter.values
-      @driver.execute(sql, values)
+      drv.execute(sql, values)
       { success: true }
     end
 
     def delete(table, filter = {})
+      cache_invalidate if @cache_enabled
+      drv = current_driver
+
       # List of hashes — delete each row
       if filter.is_a?(Array)
         filter.each { |row| delete(table, row) }
@@ -94,46 +263,48 @@ module Tina4
       if filter.is_a?(String)
         sql = "DELETE FROM #{table}"
         sql += " WHERE #{filter}" unless filter.empty?
-        @driver.execute(sql)
+        drv.execute(sql)
         return { success: true }
       end
 
       # Hash filter — build WHERE from keys
-      where_parts = filter.keys.map { |k| "#{k} = #{@driver.placeholder}" }
+      where_parts = filter.keys.map { |k| "#{k} = #{drv.placeholder}" }
       sql = "DELETE FROM #{table}"
       sql += " WHERE #{where_parts.join(' AND ')}" unless filter.empty?
-      @driver.execute(sql, filter.values)
+      drv.execute(sql, filter.values)
       { success: true }
     end
 
     def execute(sql, params = [])
-      @driver.execute(sql, params)
+      cache_invalidate if @cache_enabled
+      current_driver.execute(sql, params)
     end
 
     def execute_many(sql, params_list = [])
       total_affected = 0
       params_list.each do |params|
-        @driver.execute(sql, params)
+        current_driver.execute(sql, params)
         total_affected += 1
       end
       { success: true, affected_rows: total_affected }
     end
 
     def transaction
-      @driver.begin_transaction
+      drv = current_driver
+      drv.begin_transaction
       yield self
-      @driver.commit
+      drv.commit
     rescue => e
-      @driver.rollback
+      drv.rollback
       raise e
     end
 
     def tables
-      @driver.tables
+      current_driver.tables
     end
 
     def columns(table_name)
-      @driver.columns(table_name)
+      current_driver.columns(table_name)
     end
 
     def table_exists?(table_name)
@@ -142,6 +313,39 @@ module Tina4
 
     private
 
+    def truthy?(val)
+      %w[true 1 yes on].include?((val || "").to_s.strip.downcase)
+    end
+
+    def cache_key(sql, params)
+      Digest::SHA256.hexdigest(sql + params.to_s)
+    end
+
+    def cache_get(key)
+      @cache_mutex.synchronize do
+        entry = @query_cache[key]
+        return nil unless entry
+        if Process.clock_gettime(Process::CLOCK_MONOTONIC) > entry[:expires_at]
+          @query_cache.delete(key)
+          return nil
+        end
+        entry[:value]
+      end
+    end
+
+    def cache_set(key, value)
+      @cache_mutex.synchronize do
+        @query_cache[key] = {
+          expires_at: Process.clock_gettime(Process::CLOCK_MONOTONIC) + @cache_ttl,
+          value: value
+        }
+      end
+    end
+
+    def cache_invalidate
+      @cache_mutex.synchronize { @query_cache.clear }
+    end
+
     def detect_driver(conn)
       case conn.to_s.downcase
       when /\.db$/, /\.sqlite/, /sqlite/