tina4ruby 0.5.2 → 3.2.1

data/lib/tina4/cors.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+module Tina4
+  module CorsMiddleware
+    class << self
+      def config
+        @config ||= load_config
+      end
+
+      def reset!
+        @config = nil
+      end
+
+      # Handle OPTIONS preflight request, returns a Rack response array
+      def preflight_response(env = {})
+        origin = resolve_origin(env)
+        [
+          204,
+          {
+            "access-control-allow-origin" => origin,
+            "access-control-allow-methods" => config[:methods],
+            "access-control-allow-headers" => config[:headers],
+            "access-control-max-age" => config[:max_age],
+            "access-control-allow-credentials" => config[:credentials]
+          },
+          [""]
+        ]
+      end
+
+      # Apply CORS headers to a response headers hash
+      def apply_headers(response_headers, env = {})
+        origin = resolve_origin(env)
+        response_headers["access-control-allow-origin"] = origin
+        response_headers["access-control-allow-methods"] = config[:methods]
+        response_headers["access-control-allow-headers"] = config[:headers]
+        response_headers["access-control-max-age"] = config[:max_age]
+        response_headers["access-control-allow-credentials"] = config[:credentials] if config[:credentials] == "true"
+        response_headers
+      end
+
+      # Check if a given origin is allowed
+      def origin_allowed?(origin)
+        return true if config[:origins] == "*"
+
+        allowed = config[:origins].split(",").map(&:strip)
+        allowed.include?(origin)
+      end
+
+      private
+
+      def load_config
+        {
+          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",
+          max_age: ENV["TINA4_CORS_MAX_AGE"] || "86400",
+          credentials: ENV["TINA4_CORS_CREDENTIALS"] || "false"
+        }.freeze
+      end
+
+      def resolve_origin(env)
+        request_origin = env["HTTP_ORIGIN"] || env["HTTP_REFERER"]
+
+        if config[:origins] == "*"
+          "*"
+        elsif request_origin && origin_allowed?(request_origin.chomp("/"))
+          request_origin.chomp("/")
+        else
+          config[:origins].split(",").first&.strip || "*"
+        end
+      end
+    end
+  end
+end

data/lib/tina4/database/sqlite3_adapter.rb

@@ -0,0 +1,139 @@
+# frozen_string_literal: true
+
+module Tina4
+  module Adapters
+    class Sqlite3Adapter
+      attr_reader :connection, :db_path
+
+      def initialize(connection_string = nil)
+        @connection = nil
+        @db_path = nil
+        @in_transaction = false
+        connect(connection_string) if connection_string
+      end
+
+      def connect(connection_string)
+        require "sqlite3"
+        @db_path = connection_string.to_s.sub(/^sqlite3?:\/\//, "").sub(/^sqlite3?:/, "")
+        @connection = SQLite3::Database.new(@db_path)
+        @connection.results_as_hash = true
+        @connection.execute("PRAGMA journal_mode=WAL")
+        @connection.execute("PRAGMA foreign_keys=ON")
+        self
+      end
+
+      def close
+        @connection.close if @connection
+        @connection = nil
+      end
+
+      def connected?
+        !@connection.nil? && !@connection.closed?
+      end
+
+      # Execute a query and return rows as array of symbol-keyed hashes
+      def query(sql, params = [])
+        results = @connection.execute(sql, params)
+        results.map { |row| symbolize_keys(row) }
+      end
+
+      # Paginated fetch
+      def fetch(sql, limit = nil, offset = nil)
+        effective_sql = sql
+        if limit
+          effective_sql = "#{sql} LIMIT #{limit}"
+          effective_sql += " OFFSET #{offset}" if offset && offset > 0
+        end
+        query(effective_sql)
+      end
+
+      # Execute DDL or DML without returning rows
+      def exec(sql, params = [])
+        @connection.execute(sql, params)
+        { affected_rows: @connection.changes }
+      end
+
+      # Check if a table exists
+      def table_exists?(table)
+        rows = query(
+          "SELECT name FROM sqlite_master WHERE type='table' AND name = ?",
+          [table.to_s]
+        )
+        !rows.empty?
+      end
+
+      # Get column metadata for a table
+      def columns(table)
+        query("PRAGMA table_info(#{table})").map do |r|
+          {
+            name: r[:name],
+            type: r[:type],
+            nullable: r[:notnull] == 0,
+            default: r[:dflt_value],
+            primary_key: r[:pk] == 1
+          }
+        end
+      end
+
+      # List all user tables
+      def tables
+        rows = query("SELECT name FROM sqlite_master WHERE type='table' AND name NOT LIKE 'sqlite_%'")
+        rows.map { |r| r[:name] }
+      end
+
+      # Get last inserted row id
+      def last_insert_id
+        @connection.last_insert_row_id
+      end
+
+      # Transaction support
+      def begin_transaction
+        return if @in_transaction
+        @connection.execute("BEGIN TRANSACTION")
+        @in_transaction = true
+      end
+
+      def commit
+        return unless @in_transaction
+        @connection.execute("COMMIT")
+        @in_transaction = false
+      end
+
+      def rollback
+        return unless @in_transaction
+        @connection.execute("ROLLBACK")
+        @in_transaction = false
+      end
+
+      def transaction
+        begin_transaction
+        yield self
+        commit
+      rescue => e
+        rollback
+        raise e
+      end
+
+      # Convenience: placeholder for parameterized queries
+      def placeholder
+        "?"
+      end
+
+      def placeholders(count)
+        (["?"] * count).join(", ")
+      end
+
+      def apply_limit(sql, limit, offset = 0)
+        "#{sql} LIMIT #{limit} OFFSET #{offset}"
+      end
+
+      private
+
+      def symbolize_keys(hash)
+        hash.each_with_object({}) do |(k, v), h|
+          h[k.to_s.to_sym] = v if k.is_a?(String) || k.is_a?(Symbol)
+        end
+      end
+    end
+  end
+end

data/lib/tina4/database.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 require "json"
+require "uri"
+require "digest"
 
 module Tina4
   class Database
@@ -11,26 +13,36 @@ module Tina4
       "postgres" => "Tina4::Drivers::PostgresDriver",
       "postgresql" => "Tina4::Drivers::PostgresDriver",
       "mysql" => "Tina4::Drivers::MysqlDriver",
-      "mysql2" => "Tina4::Drivers::MysqlDriver",
       "mssql" => "Tina4::Drivers::MssqlDriver",
       "sqlserver" => "Tina4::Drivers::MssqlDriver",
       "firebird" => "Tina4::Drivers::FirebirdDriver"
     }.freeze
 
-    def initialize(connection_string, driver_name: nil)
-      @connection_string = connection_string
-      @driver_name = driver_name || detect_driver(connection_string)
+    def initialize(connection_string = nil, username: nil, password: nil, driver_name: nil)
+      @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
       @connected = false
+
+      # 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
+
       connect
     end
 
     def connect
-      @driver.connect(@connection_string)
+      @driver.connect(@connection_string, username: @username, password: @password)
       @connected = true
-      Tina4::Debug.info("Database connected: #{@driver_name}")
+      Tina4::Log.info("Database connected: #{@driver_name}")
     rescue => e
-      Tina4::Debug.error("Database connection failed: #{e.message}")
+      Tina4::Log.error("Database connection failed: #{e.message}")
       @connected = false
     end
 
@@ -39,21 +51,84 @@ module Tina4
       @connected = false
     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, skip: nil)
       effective_sql = sql
       if limit
         effective_sql = @driver.apply_limit(effective_sql, limit, skip || 0)
       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 = @driver.execute_query(effective_sql, params)
+        result = Tina4::DatabaseResult.new(result, sql: effective_sql)
+        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)
     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
+
+      # 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)
+        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)
       sql = "INSERT INTO #{table} (#{columns.join(', ')}) VALUES (#{placeholders})"
@@ -62,6 +137,8 @@ module Tina4
     end
 
     def update(table, data, filter = {})
+      cache_invalidate if @cache_enabled
+
       set_parts = data.keys.map { |k| "#{k} = #{@driver.placeholder}" }
       where_parts = filter.keys.map { |k| "#{k} = #{@driver.placeholder}" }
       sql = "UPDATE #{table} SET #{set_parts.join(', ')}"
@@ -72,6 +149,23 @@ module Tina4
     end
 
     def delete(table, filter = {})
+      cache_invalidate if @cache_enabled
+
+      # List of hashes — delete each row
+      if filter.is_a?(Array)
+        filter.each { |row| delete(table, row) }
+        return { success: true }
+      end
+
+      # String filter — raw WHERE clause
+      if filter.is_a?(String)
+        sql = "DELETE FROM #{table}"
+        sql += " WHERE #{filter}" unless filter.empty?
+        @driver.execute(sql)
+        return { success: true }
+      end
+
+      # Hash filter — build WHERE from keys
       where_parts = filter.keys.map { |k| "#{k} = #{@driver.placeholder}" }
       sql = "DELETE FROM #{table}"
       sql += " WHERE #{where_parts.join(' AND ')}" unless filter.empty?
@@ -80,9 +174,19 @@ module Tina4
     end
 
     def execute(sql, params = [])
+      cache_invalidate if @cache_enabled
       @driver.execute(sql, params)
     end
 
+    def execute_many(sql, params_list = [])
+      total_affected = 0
+      params_list.each do |params|
+        @driver.execute(sql, params)
+        total_affected += 1
+      end
+      { success: true, affected_rows: total_affected }
+    end
+
     def transaction
       @driver.begin_transaction
       yield self
@@ -106,6 +210,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/

data/lib/tina4/debug.rb

@@ -1,83 +1,8 @@
 # frozen_string_literal: true
-require "logger"
-require "fileutils"
 
-module Tina4
-  module Debug
-    LEVELS = {
-      "[TINA4_LOG_ALL]" => Logger::DEBUG,
-      "[TINA4_LOG_DEBUG]" => Logger::DEBUG,
-      "[TINA4_LOG_INFO]" => Logger::INFO,
-      "[TINA4_LOG_WARNING]" => Logger::WARN,
-      "[TINA4_LOG_ERROR]" => Logger::ERROR,
-      "[TINA4_LOG_NONE]" => Logger::FATAL
-    }.freeze
-
-    COLORS = {
-      reset: "\e[0m", red: "\e[31m", green: "\e[32m",
-      yellow: "\e[33m", blue: "\e[34m", magenta: "\e[35m",
-      cyan: "\e[36m", gray: "\e[90m"
-    }.freeze
-
-    class << self
-      def setup(root_dir = Dir.pwd)
-        log_dir = File.join(root_dir, "logs")
-        FileUtils.mkdir_p(log_dir)
-        log_file = File.join(log_dir, "debug.log")
-        @file_logger = Logger.new(log_file, 10, 5 * 1024 * 1024)
-        @file_logger.level = Logger::DEBUG
-        @console_logger = Logger.new($stdout)
-        @console_logger.level = resolve_level
-        @console_logger.formatter = method(:color_formatter)
-        @file_logger.formatter = method(:plain_formatter)
-        @initialized = true
-      end
-
-      def info(message, *args)
-        log(:info, message, *args)
-      end
-
-      def debug(message, *args)
-        log(:debug, message, *args)
-      end
-
-      def warning(message, *args)
-        log(:warn, message, *args)
-      end
+# Backward compatibility: Tina4::Debug is now Tina4::Log
+require_relative "log"
 
-      def error(message, *args)
-        log(:error, message, *args)
-      end
-
-      private
-
-      def log(level, message, *args)
-        setup unless @initialized
-        full_message = args.empty? ? message.to_s : "#{message} #{args.map(&:to_s).join(' ')}"
-        @console_logger.send(level, full_message)
-        @file_logger.send(level, full_message)
-      end
-
-      def resolve_level
-        env_level = ENV["TINA4_DEBUG_LEVEL"] || "[TINA4_LOG_ALL]"
-        LEVELS[env_level] || Logger::DEBUG
-      end
-
-      def color_formatter(severity, datetime, _progname, message)
-        color = case severity
-                when "DEBUG" then COLORS[:gray]
-                when "INFO"  then COLORS[:green]
-                when "WARN"  then COLORS[:yellow]
-                when "ERROR" then COLORS[:red]
-                else COLORS[:reset]
-                end
-        ts = datetime.strftime("%Y-%m-%d %H:%M:%S")
-        "#{COLORS[:gray]}[#{ts}]#{COLORS[:reset]} #{color}[#{severity}]#{COLORS[:reset]} #{message}\n"
-      end
-
-      def plain_formatter(severity, datetime, _progname, message)
-        "[#{datetime.strftime('%Y-%m-%d %H:%M:%S')}] [#{severity}] #{message}\n"
-      end
-    end
-  end
+module Tina4
+  Debug = Log
 end