tina4ruby 3.10.50 → 3.10.55

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: abf3c5a919a2ef3d8045a321ff7199560cc9d984afbbfce65517728b2f12ae3c
-  data.tar.gz: c7976150a47140a2585fd5adc19ccc66b6dbeaeeb38bdcdbf405bb239006acfe
+  metadata.gz: 25b4d9017318ffe796da35f53d7865bd5ce5cad601a25d6dbffa512c649cd019
+  data.tar.gz: 6ee84f47f431b714ff0b4ac84ff606c3406ca5e2896d17a0835b98f23ac9385f
 SHA512:
-  metadata.gz: 8d2167a92355ee4d21810bd3999cd67993f48ab3be21ca7d2e85f83c5b51cfcc225a0d5db40213feecad93cb9548640fa3f80b06d43ede6bc0270fe06af98e07
-  data.tar.gz: 3afbe6fa4642493a511949cbf0f324224e1fccbedaaa1edd18790bbbb8fcfaf2c29f1d8bb0a13d4ec16f94b8c4234b1e4d41603b9194763a9c3dd9dce60b0d04
+  metadata.gz: eb0387a9321fb64193433c5d975bce3f7cfb2d25af20dcf9786cf361f6471cfecbbecad9a026e60f95f34446aa1fef65d77d93d19acb14ca7b1b6e615924cbb4
+  data.tar.gz: 73a21f6cd92dda7b2a747d824b68685e827d87b4e42ae92fb2313e69af5fef4e3704e7bca70674045ed5f149926ff4a9fc2ae8a1de2ea2a6bd41e70d4de14aa6

data/lib/tina4/auto_crud.rb

@@ -55,8 +55,10 @@ module Tina4
         # GET /api/{table} -- list all with pagination, filtering, sorting
         Tina4::Router.add_route("GET", "#{prefix}/#{table}", proc { |req, res|
           begin
-            limit = (req.query["limit"] || 10).to_i
-            offset = (req.query["offset"] || 0).to_i
+            per_page = (req.query["per_page"] || req.query["limit"] || 10).to_i
+            page     = (req.query["page"] || 1).to_i
+            limit    = per_page
+            offset   = req.query["offset"] ? req.query["offset"].to_i : (page - 1) * per_page
             order_by = parse_sort(req.query["sort"])
 
             # Filter support: ?filter[field]=value

data/lib/tina4/cli.rb

@@ -155,7 +155,7 @@ module Tina4
     # ── start ─────────────────────────────────────────────────────────────
 
     def cmd_start(argv)
-      options = { port: nil, host: nil, dev: false, no_browser: false, production: false }
+      options = { port: nil, host: nil, dev: false, no_browser: false, no_reload: false, production: false }
       parser = OptionParser.new do |opts|
         opts.banner = "Usage: tina4ruby start [options]"
         opts.on("-p", "--port PORT", Integer, "Port (default: 7147)") { |v| options[:port] = v }
@@ -163,6 +163,7 @@ module Tina4
         opts.on("-d", "--dev", "Enable dev mode with auto-reload") { options[:dev] = true }
         opts.on("--production", "Use production server (Puma)") { options[:production] = true }
         opts.on("--no-browser", "Do not open browser on start") { options[:no_browser] = true }
+        opts.on("--no-reload", "Disable file watcher / live-reload") { options[:no_reload] = true }
       end
       parser.parse!(argv)
 
@@ -172,6 +173,11 @@ module Tina4
         options[:no_browser] = true
       end
 
+      # --no-reload flag sets TINA4_NO_RELOAD so the existing env check picks it up
+      if options[:no_reload]
+        ENV["TINA4_NO_RELOAD"] = "true"
+      end
+
       # Priority: CLI flag > ENV var > default
       options[:port] = resolve_config(:port, options[:port])
       options[:host] = resolve_config(:host, options[:host])
@@ -191,7 +197,8 @@ module Tina4
       load_routes(root_dir)
 
       if options[:dev]
-        Tina4::DevReload.start(root_dir: root_dir)
+        no_reload = %w[true 1 yes].include?(ENV.fetch("TINA4_NO_RELOAD", "").downcase)
+        Tina4::DevReload.start(root_dir: root_dir) unless no_reload
         Tina4::ScssCompiler.compile_all(root_dir)
       end
 

data/lib/tina4/cors.rb

@@ -66,7 +66,7 @@ module Tina4
         elsif request_origin && origin_allowed?(request_origin.chomp("/"))
           request_origin.chomp("/")
         else
-          config[:origins].split(",").first&.strip || "*"
+          ""
         end
       end
     end

data/lib/tina4/database.rb

@@ -76,7 +76,10 @@ module Tina4
       "mysql" => "Tina4::Drivers::MysqlDriver",
       "mssql" => "Tina4::Drivers::MssqlDriver",
       "sqlserver" => "Tina4::Drivers::MssqlDriver",
-      "firebird" => "Tina4::Drivers::FirebirdDriver"
+      "firebird" => "Tina4::Drivers::FirebirdDriver",
+      "mongodb" => "Tina4::Drivers::MongodbDriver",
+      "mongo" => "Tina4::Drivers::MongodbDriver",
+      "odbc" => "Tina4::Drivers::OdbcDriver"
     }.freeze
 
     def initialize(connection_string = nil, username: nil, password: nil, driver_name: nil, pool: 0)
@@ -491,6 +494,10 @@ module Tina4
         "mssql"
       when /firebird/, /\.fdb$/
         "firebird"
+      when /mongodb/, /^mongo:/
+        "mongodb"
+      when /^odbc:/
+        "odbc"
       else
         "sqlite"
       end

data/lib/tina4/database_result.rb

@@ -86,10 +86,15 @@ module Tina4
       slice_offset = (page - 1) * per_page
       page_records = @records[slice_offset, per_page] || []
       {
+        records: page_records,
         data: page_records,
+        count: total,
+        total: total,
+        limit: per_page,
+        offset: (page - 1) * per_page,
         page: page,
         per_page: per_page,
-        total: total,
+        totalPages: total_pages,
         total_pages: total_pages,
         has_next: page < total_pages,
         has_prev: page > 1

data/lib/tina4/drivers/mongodb_driver.rb

@@ -0,0 +1,561 @@
+# frozen_string_literal: true
+
+module Tina4
+  module Drivers
+    class MongodbDriver
+      attr_reader :connection, :db
+
+      def connect(connection_string, username: nil, password: nil)
+        begin
+          require "mongo"
+        rescue LoadError
+          raise LoadError,
+            "The 'mongo' gem is required for MongoDB connections. " \
+            "Install: gem install mongo"
+        end
+
+        uri = build_uri(connection_string, username, password)
+        @db_name = extract_db_name(connection_string)
+        @client = Mongo::Client.new(uri)
+        @db = @client.use(@db_name)
+        @connection = @db
+        @last_insert_id = nil
+      end
+
+      def close
+        @client&.close
+        @client = nil
+        @db = nil
+        @connection = nil
+      end
+
+      # Execute a query (SELECT-like) and return array of symbol-keyed hashes
+      def execute_query(sql, params = [])
+        parsed = parse_sql(sql, params)
+        collection = @db[parsed[:collection]]
+
+        case parsed[:operation]
+        when :find
+          cursor = collection.find(parsed[:filter] || {})
+          cursor = cursor.projection(parsed[:projection]) if parsed[:projection] && !parsed[:projection].empty?
+          cursor = cursor.sort(parsed[:sort]) if parsed[:sort] && !parsed[:sort].empty?
+          cursor = cursor.skip(parsed[:skip]) if parsed[:skip] && parsed[:skip] > 0
+          cursor = cursor.limit(parsed[:limit]) if parsed[:limit] && parsed[:limit] > 0
+          cursor.map { |doc| mongo_doc_to_hash(doc) }
+        else
+          []
+        end
+      end
+
+      # Execute a DML statement (INSERT, UPDATE, DELETE, CREATE)
+      def execute(sql, params = [])
+        parsed = parse_sql(sql, params)
+        collection = @db[parsed[:collection]]
+
+        case parsed[:operation]
+        when :insert
+          result = collection.insert_one(parsed[:document])
+          @last_insert_id = result.inserted_id.to_s
+          result
+        when :update
+          collection.update_many(parsed[:filter] || {}, { "$set" => parsed[:updates] })
+        when :delete
+          collection.delete_many(parsed[:filter] || {})
+        when :create_collection
+          begin
+            @db.command(create: parsed[:collection].to_s)
+          rescue Mongo::Error::OperationFailure
+            # Collection already exists — ignore
+          end
+          nil
+        when :find
+          execute_query(sql, params)
+        else
+          nil
+        end
+      end
+
+      def last_insert_id
+        @last_insert_id
+      end
+
+      def placeholder
+        "?"
+      end
+
+      def placeholders(count)
+        (["?"] * count).join(", ")
+      end
+
+      # MongoDB has no LIMIT clause — ignore; already handled in execute_query
+      def apply_limit(sql, limit, offset = 0)
+        sql_up = sql.upcase
+        return sql if sql_up.include?("LIMIT")
+        modified = sql.dup
+        modified += " LIMIT #{limit}" if limit && limit > 0
+        modified += " OFFSET #{offset}" if offset && offset > 0
+        modified
+      end
+
+      # MongoDB transactions require a replica set — wrap in session if available
+      def begin_transaction
+        # no-op for standalone; transaction support via session handled externally
+      end
+
+      def commit
+        # no-op
+      end
+
+      def rollback
+        # no-op
+      end
+
+      def tables
+        @db.collection_names.reject { |n| n.start_with?("system.") }
+      end
+
+      def columns(table_name)
+        collection = @db[table_name.to_s]
+        sample = collection.find.limit(1).first
+        return [] unless sample
+
+        sample.keys.map do |key|
+          {
+            name: key,
+            type: sample[key].class.name,
+            nullable: true,
+            default: nil,
+            primary_key: key == "_id"
+          }
+        end
+      end
+
+      private
+
+      def build_uri(connection_string, username, password)
+        uri = connection_string.to_s
+        # Normalise scheme: mongodb:// stays, mongo:// becomes mongodb://
+        uri = uri.sub(/^mongo:\/\//, "mongodb://")
+
+        if username || password
+          # Inject credentials into the URI if not already present
+          if uri =~ /^mongodb:\/\/([^@]+@)/
+            # credentials already in URI — leave as-is
+          else
+            host_part = uri.sub(/^mongodb:\/\//, "")
+            creds = [username, password ? ":#{password}" : nil].compact.join
+            uri = "mongodb://#{creds}@#{host_part}"
+          end
+        end
+        uri
+      end
+
+      def extract_db_name(connection_string)
+        # mongodb://host:port/dbname  ->  dbname
+        # Strip query string first
+        path = connection_string.to_s.split("?").first
+        db = path.split("/").last
+        db && !db.empty? ? db : "tina4"
+      end
+
+      # ── SQL-to-MongoDB translator ──────────────────────────────────────
+
+      def parse_sql(sql, params = [])
+        sql_stripped = sql.strip
+        upper = sql_stripped.upcase
+
+        # Bind positional ? params
+        bound_sql = bind_params(sql_stripped, params)
+
+        if upper.start_with?("SELECT")
+          parse_select(bound_sql)
+        elsif upper.start_with?("INSERT INTO")
+          parse_insert(bound_sql)
+        elsif upper.start_with?("UPDATE")
+          parse_update(bound_sql)
+        elsif upper.start_with?("DELETE FROM")
+          parse_delete(bound_sql)
+        elsif upper.start_with?("CREATE TABLE") || upper.start_with?("CREATE COLLECTION")
+          parse_create(bound_sql)
+        else
+          { operation: :unknown, collection: nil }
+        end
+      end
+
+      def bind_params(sql, params)
+        return sql if params.nil? || params.empty?
+
+        idx = -1
+        sql.gsub("?") do
+          idx += 1
+          v = params[idx]
+          v.is_a?(String) ? "'#{v.gsub("'", "\\\\'")}'" : v.to_s
+        end
+      end
+
+      # ── SELECT parsing ─────────────────────────────────────────────────
+
+      def parse_select(sql)
+        result = { operation: :find }
+
+        # Extract table name (FROM clause)
+        if (m = sql.match(/\bFROM\s+(\w+)/i))
+          result[:collection] = m[1].to_sym
+        else
+          result[:collection] = :unknown
+          return result
+        end
+
+        # Projection (columns)
+        result[:projection] = parse_projection(sql)
+
+        # WHERE clause
+        where_clause = extract_clause(sql, "WHERE", %w[ORDER GROUP LIMIT OFFSET HAVING])
+        result[:filter] = where_clause ? parse_where(where_clause) : {}
+
+        # ORDER BY
+        result[:sort] = parse_order_by(sql)
+
+        # LIMIT / OFFSET
+        result[:limit] = extract_limit(sql)
+        result[:skip]  = extract_offset(sql)
+
+        result
+      end
+
+      def parse_projection(sql)
+        m = sql.match(/^SELECT\s+(.*?)\s+FROM\b/im)
+        return {} unless m
+
+        cols = m[1].strip
+        return {} if cols == "*"
+
+        proj = {}
+        cols.split(",").each do |col|
+          col = col.strip
+          # Handle AS aliases — use the alias as field name
+          field = col.split(/\s+AS\s+/i).first.strip
+          proj[field] = 1
+        end
+        proj
+      end
+
+      def parse_order_by(sql)
+        m = sql.match(/\bORDER\s+BY\s+(.*?)(?:\s+LIMIT|\s+OFFSET|\s*$)/im)
+        return {} unless m
+
+        sort = {}
+        m[1].split(",").each do |part|
+          part = part.strip
+          if (pm = part.match(/^(\w+)\s+(ASC|DESC)$/i))
+            sort[pm[1]] = pm[2].upcase == "DESC" ? -1 : 1
+          else
+            sort[part] = 1
+          end
+        end
+        sort
+      end
+
+      def extract_limit(sql)
+        m = sql.match(/\bLIMIT\s+(\d+)/i)
+        m ? m[1].to_i : nil
+      end
+
+      def extract_offset(sql)
+        m = sql.match(/\bOFFSET\s+(\d+)/i)
+        m ? m[1].to_i : nil
+      end
+
+      # ── WHERE clause parser → Mongo filter hash ───────────────────────
+
+      def parse_where(clause)
+        clause = clause.strip
+        return {} if clause.empty?
+
+        # Handle OR at top level
+        or_parts = split_top_level(clause, /\bOR\b/i)
+        if or_parts.length > 1
+          return { "$or" => or_parts.map { |p| parse_where(p) } }
+        end
+
+        # Handle AND at top level
+        and_parts = split_top_level(clause, /\bAND\b/i)
+        if and_parts.length > 1
+          conditions = and_parts.map { |p| parse_where(p) }
+          merged = {}
+          conditions.each { |c| merged.merge!(c) }
+          return merged
+        end
+
+        parse_condition(clause)
+      end
+
+      # Split a string on a regex delimiter only at top level (not inside parens)
+      def split_top_level(str, delimiter_re)
+        parts = []
+        depth = 0
+        current = ""
+        tokens = str.split(/(\(|\)|\s+)/m)
+
+        # Rebuild token stream and split on delimiter
+        rebuilt = str
+        # Simple approach: scan character by character
+        parts = []
+        current = ""
+        i = 0
+        while i < str.length
+          ch = str[i]
+          if ch == "("
+            depth += 1
+            current += ch
+          elsif ch == ")"
+            depth -= 1
+            current += ch
+          elsif depth == 0
+            # Check for delimiter match at this position
+            remaining = str[i..]
+            m = remaining.match(/\A\s*#{delimiter_re.source}\s*/i)
+            if m
+              parts << current.strip
+              current = ""
+              i += m[0].length
+              next
+            else
+              current += ch
+            end
+          else
+            current += ch
+          end
+          i += 1
+        end
+        parts << current.strip unless current.strip.empty?
+        parts.length > 1 ? parts : [str]
+      end
+
+      def parse_condition(clause)
+        clause = clause.strip.gsub(/^\(+/, "").gsub(/\)+$/, "").strip
+
+        # IS NULL / IS NOT NULL
+        if (m = clause.match(/^(\w+)\s+IS\s+NOT\s+NULL$/i))
+          return { m[1] => { "$ne" => nil } }
+        end
+        if (m = clause.match(/^(\w+)\s+IS\s+NULL$/i))
+          return { m[1] => nil }
+        end
+
+        # IN (...)
+        if (m = clause.match(/^(\w+)\s+IN\s*\((.+)\)$/i))
+          values = m[2].split(",").map { |v| parse_value(v.strip) }
+          return { m[1] => { "$in" => values } }
+        end
+
+        # NOT IN (...)
+        if (m = clause.match(/^(\w+)\s+NOT\s+IN\s*\((.+)\)$/i))
+          values = m[2].split(",").map { |v| parse_value(v.strip) }
+          return { m[1] => { "$nin" => values } }
+        end
+
+        # LIKE → $regex
+        if (m = clause.match(/^(\w+)\s+LIKE\s+'(.+)'$/i))
+          pattern = m[2].gsub("%", ".*").gsub("_", ".")
+          return { m[1] => { "$regex" => pattern, "$options" => "i" } }
+        end
+
+        # NOT LIKE → $not $regex
+        if (m = clause.match(/^(\w+)\s+NOT\s+LIKE\s+'(.+)'$/i))
+          pattern = m[2].gsub("%", ".*").gsub("_", ".")
+          return { m[1] => { "$not" => /#{pattern}/i } }
+        end
+
+        # Comparison operators: !=, <>, >=, <=, >, <, =
+        ops = [["!=", "$ne"], ["<>", "$ne"], [">=", "$gte"], ["<=", "$lte"],
+               [">", "$gt"], ["<", "$lt"], ["=", "$eq"]]
+        ops.each do |op, mongo_op|
+          if (m = clause.match(/^(\w+)\s*#{Regexp.escape(op)}\s*(.+)$/i))
+            field = m[1]
+            value = parse_value(m[2].strip)
+            if mongo_op == "$eq"
+              return { field => value }
+            else
+              return { field => { mongo_op => value } }
+            end
+          end
+        end
+
+        # Fallback — return as a raw string comment (best-effort)
+        {}
+      end
+
+      def parse_value(str)
+        str = str.strip
+        if str.start_with?("'") && str.end_with?("'")
+          str[1..-2]
+        elsif str =~ /\A-?\d+\z/
+          str.to_i
+        elsif str =~ /\A-?\d+\.\d+\z/
+          str.to_f
+        elsif str.upcase == "TRUE"
+          true
+        elsif str.upcase == "FALSE"
+          false
+        elsif str.upcase == "NULL"
+          nil
+        else
+          str
+        end
+      end
+
+      # ── INSERT parsing ─────────────────────────────────────────────────
+
+      def parse_insert(sql)
+        result = { operation: :insert }
+
+        m = sql.match(/INSERT\s+INTO\s+(\w+)\s*\(([^)]+)\)\s*VALUES\s*\(([^)]+)\)/im)
+        unless m
+          result[:collection] = :unknown
+          result[:document] = {}
+          return result
+        end
+
+        result[:collection] = m[1].to_sym
+        cols = m[2].split(",").map(&:strip)
+        vals = parse_value_list(m[3])
+
+        result[:document] = cols.each_with_object({}).with_index do |(col, doc), i|
+          doc[col] = vals[i]
+        end
+
+        result
+      end
+
+      def parse_value_list(str)
+        # Split on commas not inside quotes
+        vals = []
+        current = ""
+        in_quote = false
+        str.each_char do |ch|
+          if ch == "'" && !in_quote
+            in_quote = true
+            current += ch
+          elsif ch == "'" && in_quote
+            in_quote = false
+            current += ch
+          elsif ch == "," && !in_quote
+            vals << parse_value(current.strip)
+            current = ""
+          else
+            current += ch
+          end
+        end
+        vals << parse_value(current.strip) unless current.strip.empty?
+        vals
+      end
+
+      # ── UPDATE parsing ─────────────────────────────────────────────────
+
+      def parse_update(sql)
+        result = { operation: :update }
+
+        m = sql.match(/UPDATE\s+(\w+)\s+SET\s+(.+?)(?:\s+WHERE\s+(.+))?$/im)
+        unless m
+          result[:collection] = :unknown
+          result[:updates] = {}
+          result[:filter] = {}
+          return result
+        end
+
+        result[:collection] = m[1].to_sym
+
+        # Parse SET assignments
+        updates = {}
+        set_clause = m[2].strip
+        # Split on comma, skip commas inside quotes
+        assignments = split_assignments(set_clause)
+        assignments.each do |assign|
+          parts = assign.split("=", 2)
+          next unless parts.length == 2
+
+          key = parts[0].strip
+          val = parse_value(parts[1].strip)
+          updates[key] = val
+        end
+        result[:updates] = updates
+
+        # Parse WHERE
+        where_str = m[3]&.strip
+        result[:filter] = where_str && !where_str.empty? ? parse_where(where_str) : {}
+
+        result
+      end
+
+      def split_assignments(set_clause)
+        parts = []
+        current = ""
+        in_quote = false
+        set_clause.each_char do |ch|
+          if ch == "'" && !in_quote
+            in_quote = true
+            current += ch
+          elsif ch == "'" && in_quote
+            in_quote = false
+            current += ch
+          elsif ch == "," && !in_quote
+            parts << current.strip
+            current = ""
+          else
+            current += ch
+          end
+        end
+        parts << current.strip unless current.strip.empty?
+        parts
+      end
+
+      # ── DELETE parsing ─────────────────────────────────────────────────
+
+      def parse_delete(sql)
+        result = { operation: :delete }
+
+        m = sql.match(/DELETE\s+FROM\s+(\w+)(?:\s+WHERE\s+(.+))?$/im)
+        unless m
+          result[:collection] = :unknown
+          result[:filter] = {}
+          return result
+        end
+
+        result[:collection] = m[1].to_sym
+        where_str = m[2]&.strip
+        result[:filter] = where_str && !where_str.empty? ? parse_where(where_str) : {}
+
+        result
+      end
+
+      # ── CREATE TABLE parsing ───────────────────────────────────────────
+
+      def parse_create(sql)
+        m = sql.match(/CREATE\s+(?:TABLE|COLLECTION)\s+(?:IF\s+NOT\s+EXISTS\s+)?(\w+)/im)
+        {
+          operation: :create_collection,
+          collection: m ? m[1].to_sym : :unknown
+        }
+      end
+
+      # ── Extract a named clause from SQL ───────────────────────────────
+
+      def extract_clause(sql, clause_keyword, stop_keywords = [])
+        pattern_parts = stop_keywords.map { |kw| "\\b#{kw}\\b" }.join("|")
+        stop_pattern = pattern_parts.empty? ? "$" : "(?:#{pattern_parts}|$)"
+        m = sql.match(/\b#{clause_keyword}\s+(.*?)(?=\s*#{stop_pattern})/im)
+        m ? m[1].strip : nil
+      end
+
+      # ── Document conversion ────────────────────────────────────────────
+
+      def mongo_doc_to_hash(doc)
+        doc.each_with_object({}) do |(k, v), h|
+          key = k.to_s == "_id" ? :_id : k.to_s.to_sym
+          h[key] = v.is_a?(BSON::ObjectId) ? v.to_s : v
+        end
+      end
+    end
+  end
+end

data/lib/tina4/drivers/odbc_driver.rb

@@ -0,0 +1,191 @@
+# frozen_string_literal: true
+
+module Tina4
+  module Drivers
+    class OdbcDriver
+      attr_reader :connection
+
+      # Connect to an ODBC data source.
+      #
+      # Connection string formats:
+      #   odbc:///DSN=MyDSN
+      #   odbc:///DSN=MyDSN;UID=user;PWD=pass
+      #   odbc:///DRIVER={SQL Server};SERVER=host;DATABASE=db
+      #
+      # The leading scheme prefix "odbc:///" is stripped; the remainder is
+      # passed verbatim to ODBC::Database.new as a connection string.
+      # username: and password: are appended as UID/PWD if not already present
+      # in the connection string.
+      def connect(connection_string, username: nil, password: nil)
+        begin
+          require "odbc"
+        rescue LoadError
+          raise LoadError,
+            "The 'ruby-odbc' gem is required for ODBC connections. " \
+            "Install: gem install ruby-odbc"
+        end
+
+        dsn_string = connection_string.to_s
+          .sub(/^odbc:\/\/\//, "")
+          .sub(/^odbc:\/\//, "")
+          .sub(/^odbc:/, "")
+
+        # Append credentials if provided and not already embedded
+        if username && !dsn_string.match?(/\bUID=/i)
+          dsn_string = "#{dsn_string};UID=#{username}"
+        end
+        if password && !dsn_string.match?(/\bPWD=/i)
+          dsn_string = "#{dsn_string};PWD=#{password}"
+        end
+
+        @connection = ODBC::Database.new(dsn_string)
+        @in_transaction = false
+        self
+      end
+
+      def close
+        @connection&.disconnect
+        @connection = nil
+      end
+
+      def connected?
+        !@connection.nil?
+      end
+
+      # Execute a SELECT query and return rows as an array of symbol-keyed hashes.
+      def execute_query(sql, params = [])
+        stmt = if params && !params.empty?
+          s = @connection.prepare(sql)
+          s.execute(*params)
+          s
+        else
+          @connection.run(sql)
+        end
+
+        columns = stmt.columns(true).map { |c| c.name.to_s.to_sym }
+        rows = []
+        while (row = stmt.fetch)
+          rows << columns.zip(row).to_h
+        end
+        stmt.drop
+        rows
+      rescue => e
+        stmt&.drop rescue nil
+        raise e
+      end
+
+      # Execute DDL or DML without returning rows.
+      def execute(sql, params = [])
+        if params && !params.empty?
+          stmt = @connection.prepare(sql)
+          stmt.execute(*params)
+          stmt.drop
+        else
+          @connection.do(sql)
+        end
+        nil
+      end
+
+      # ODBC does not expose a universal last-insert-id API.
+      # Drivers that support it can be queried via execute_query after insert.
+      def last_insert_id
+        nil
+      end
+
+      def placeholder
+        "?"
+      end
+
+      def placeholders(count)
+        (["?"] * count).join(", ")
+      end
+
+      # Build paginated SQL.
+      # Tries OFFSET/FETCH NEXT (SQL Server, newer ODBC sources) first.
+      # Falls back to LIMIT/OFFSET for sources that support it (MySQL, PostgreSQL via ODBC).
+      # The caller (Database#fetch) already gates on whether LIMIT is already present.
+      def apply_limit(sql, limit, offset = 0)
+        offset ||= 0
+        if offset > 0
+          # SQL Server / ANSI syntax — requires ORDER BY; add a no-op if absent
+          if sql.upcase.include?("ORDER BY")
+            "#{sql} OFFSET #{offset} ROWS FETCH NEXT #{limit} ROWS ONLY"
+          else
+            # LIMIT/OFFSET fallback (MySQL, PostgreSQL via ODBC, SQLite via ODBC)
+            "#{sql} LIMIT #{limit} OFFSET #{offset}"
+          end
+        else
+          "#{sql} LIMIT #{limit}"
+        end
+      end
+
+      def begin_transaction
+        return if @in_transaction
+        @connection.autocommit = false
+        @in_transaction = true
+      end
+
+      def commit
+        return unless @in_transaction
+        @connection.commit
+        @connection.autocommit = true
+        @in_transaction = false
+      end
+
+      def rollback
+        return unless @in_transaction
+        @connection.rollback
+        @connection.autocommit = true
+        @in_transaction = false
+      end
+
+      # List all user tables via ODBC metadata.
+      def tables
+        stmt = @connection.tables
+        rows = []
+        while (row = stmt.fetch_hash)
+          type = row["TABLE_TYPE"] || row[:TABLE_TYPE] || ""
+          name = row["TABLE_NAME"] || row[:TABLE_NAME]
+          rows << name.to_s if type.to_s.upcase == "TABLE" && name
+        end
+        stmt.drop
+        rows
+      rescue => e
+        stmt&.drop rescue nil
+        raise e
+      end
+
+      # Return column metadata for a table via ODBC metadata.
+      def columns(table_name)
+        stmt = @connection.columns(table_name.to_s)
+        result = []
+        while (row = stmt.fetch_hash)
+          name    = row["COLUMN_NAME"]    || row[:COLUMN_NAME]
+          type    = row["TYPE_NAME"]      || row[:TYPE_NAME]
+          nullable_val = row["NULLABLE"]  || row[:NULLABLE]
+          default = row["COLUMN_DEF"]     || row[:COLUMN_DEF]
+          result << {
+            name: name.to_s,
+            type: type.to_s,
+            nullable: nullable_val.to_i == 1,
+            default: default,
+            primary_key: false  # ODBC metadata does not reliably expose PK flag here
+          }
+        end
+        stmt.drop
+        result
+      rescue => e
+        stmt&.drop rescue nil
+        raise e
+      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/orm.rb

@@ -18,7 +18,7 @@ module Tina4
 
     class << self
       def db
-        @db || Tina4.database
+        @db || Tina4.database || auto_discover_db
       end
 
       # Per-model database binding
@@ -345,6 +345,13 @@ module Tina4
 
       private
 
+      def auto_discover_db
+        url = ENV["DATABASE_URL"]
+        return nil unless url
+        Tina4.database = Tina4::Database.new(url, username: ENV.fetch("DATABASE_USERNAME", ""), password: ENV.fetch("DATABASE_PASSWORD", ""))
+        Tina4.database
+      end
+
       def find_by_id(id)
         pk = primary_key_field || :id
         sql = "SELECT * FROM #{table_name} WHERE #{pk} = ?"
@@ -642,5 +649,42 @@ module Tina4
 
       @relationship_cache[name] = klass.find(fk_value)
     end
+
+    public
+
+    # ── Imperative relationship methods (ad-hoc, like Python/PHP/Node) ──
+
+    def query_has_one(related_class, foreign_key: nil)
+      pk = self.class.primary_key_field || :id
+      pk_value = __send__(pk)
+      return nil unless pk_value
+
+      fk = foreign_key || "#{self.class.name.split('::').last.downcase}_id"
+      result = related_class.db.fetch_one(
+        "SELECT * FROM #{related_class.table_name} WHERE #{fk} = ?", [pk_value]
+      )
+      result ? related_class.from_hash(result) : nil
+    end
+
+    def query_has_many(related_class, foreign_key: nil, limit: 100, offset: 0)
+      pk = self.class.primary_key_field || :id
+      pk_value = __send__(pk)
+      return [] unless pk_value
+
+      fk = foreign_key || "#{self.class.name.split('::').last.downcase}_id"
+      results = related_class.db.fetch(
+        "SELECT * FROM #{related_class.table_name} WHERE #{fk} = ?",
+        [pk_value], limit: limit, offset: offset
+      )
+      results.map { |row| related_class.from_hash(row) }
+    end
+
+    def query_belongs_to(related_class, foreign_key: nil)
+      fk = foreign_key || "#{related_class.name.split('::').last.downcase}_id"
+      fk_value = respond_to?(fk.to_sym) ? __send__(fk.to_sym) : nil
+      return nil unless fk_value
+
+      related_class.find(fk_value)
+    end
   end
 end

data/lib/tina4/rack_app.rb

@@ -3,6 +3,19 @@ require "json"
 require "securerandom"
 
 module Tina4
+  # Middleware wrapper that tags requests arriving on the AI dev port.
+  # Suppresses live-reload behaviour so AI tools get stable responses.
+  class AiPortRackApp
+    def initialize(app)
+      @app = app
+    end
+
+    def call(env)
+      env["tina4.ai_port"] = true
+      @app.call(env)
+    end
+  end
+
   class RackApp
     STATIC_DIRS = %w[public src/public src/assets assets].freeze
 
@@ -43,6 +56,10 @@ module Tina4
 
       # Dev dashboard routes (handled before anything else)
       if path.start_with?("/__dev")
+        # Block live-reload endpoint on the AI port — AI tools must get stable responses
+        if path == "/__dev_reload" && env["tina4.ai_port"]
+          return [404, { "content-type" => "text/plain" }, ["Not available on AI port"]]
+        end
         dev_response = Tina4::DevAdmin.handle_request(env)
         return dev_response if dev_response
       end
@@ -95,7 +112,7 @@ module Tina4
             matched_pattern: matched_pattern || "(no match)",
           }
           joined = body_parts.join
-          overlay = inject_dev_overlay(joined, request_info)
+          overlay = inject_dev_overlay(joined, request_info, ai_port: env["tina4.ai_port"])
           rack_response = [status, headers, [overlay]]
         end
       end
@@ -630,7 +647,7 @@ module Tina4
       [-1, {}, []]
     end
 
-    def inject_dev_overlay(body, request_info)
+    def inject_dev_overlay(body, request_info, ai_port: false)
       version = Tina4::VERSION
       method = request_info[:method]
       path = request_info[:path]
@@ -638,9 +655,11 @@ module Tina4
       request_id = Tina4::Log.request_id || "-"
       route_count = Tina4::Router.routes.length
 
+      ai_badge = ai_port ? '<span style="background:#7c3aed;color:#fff;font-size:10px;padding:1px 6px;border-radius:3px;font-weight:bold;">AI PORT</span>' : ""
+
       toolbar = <<~HTML.strip
         <div id="tina4-dev-toolbar" style="position:fixed;bottom:0;left:0;right:0;background:#333;color:#fff;font-family:monospace;font-size:12px;padding:6px 16px;z-index:99999;display:flex;align-items:center;gap:16px;">
-            <span id="tina4-ver-btn" style="color:#d32f2f;font-weight:bold;cursor:pointer;text-decoration:underline dotted;" onclick="tina4VersionModal()" title="Click to check for updates">Tina4 v#{version}</span>
+            #{ai_badge}<span id="tina4-ver-btn" style="color:#d32f2f;font-weight:bold;cursor:pointer;text-decoration:underline dotted;" onclick="tina4VersionModal()" title="Click to check for updates">Tina4 v#{version}</span>
             <div id="tina4-ver-modal" style="display:none;position:fixed;bottom:3rem;left:1rem;background:#1e1e2e;border:1px solid #d32f2f;border-radius:8px;padding:16px 20px;z-index:100000;min-width:320px;box-shadow:0 8px 32px rgba(0,0,0,0.5);font-family:monospace;font-size:13px;color:#cdd6f4;">
               <div style="display:flex;justify-content:space-between;align-items:center;margin-bottom:12px;">
                 <strong style="color:#89b4fa;">Version Info</strong>
@@ -709,6 +728,7 @@ module Tina4
                 el.style.color='#f38ba8';
             });
         }
+        #{ai_port ? "" : "/* tina4:reload-js */"}
         </script>
       HTML
 

data/lib/tina4/version.rb

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

data/lib/tina4/webserver.rb

@@ -11,6 +11,7 @@ module Tina4
     def start
       require "webrick"
       require "stringio"
+      require "socket"
       Tina4.print_banner(host: @host, port: @port)
       Tina4::Log.info("Starting Tina4 WEBrick server on http://#{@host}:#{@port}")
       @server = WEBrick::HTTPServer.new(
@@ -101,10 +102,117 @@ module Tina4
       servlet.define_method(:webrick_req_port) { port }
 
       @server.mount("/", servlet, rack_app)
+
+      # AI dev port (port + 1) — no-reload, no-browser
+      @ai_server = nil
+      @ai_thread = nil
+      no_ai_port = %w[true 1 yes].include?(ENV.fetch("TINA4_NO_AI_PORT", "").downcase)
+      is_debug   = %w[true 1 yes].include?(ENV.fetch("TINA4_DEBUG", "").downcase)
+
+      if is_debug && !no_ai_port
+        ai_port = @port + 1
+        begin
+          test = TCPServer.new("0.0.0.0", ai_port)
+          test.close
+
+          @ai_server = WEBrick::HTTPServer.new(
+            BindAddress: @host,
+            Port: ai_port,
+            Logger: WEBrick::Log.new(File::NULL),
+            AccessLog: []
+          )
+
+          # Wrap the rack app so AI-port requests are tagged
+          ai_rack_app = Tina4::AiPortRackApp.new(@app)
+
+          # Build a servlet identical to the main one but bound to the AI port host/port
+          ai_host = @host
+          ai_port_str = ai_port.to_s
+          ai_servlet = Class.new(WEBrick::HTTPServlet::AbstractServlet) do
+            define_method(:initialize) do |server, app|
+              super(server)
+              @app = app
+            end
+
+            %w[GET POST PUT DELETE PATCH HEAD OPTIONS].each do |http_method|
+              define_method("do_#{http_method}") do |webrick_req, webrick_res|
+                handle_request(webrick_req, webrick_res)
+              end
+            end
+
+            define_method(:handle_request) do |webrick_req, webrick_res|
+              if Tina4::Shutdown.shutting_down?
+                webrick_res.status = 503
+                webrick_res.body = '{"error":"Service shutting down"}'
+                webrick_res["content-type"] = "application/json"
+                return
+              end
+
+              Tina4::Shutdown.track_request do
+                env = build_rack_env(webrick_req)
+                status, headers, body = @app.call(env)
+
+                webrick_res.status = status
+                headers.each do |key, value|
+                  if key.downcase == "set-cookie"
+                    Array(value.split("\n")).each { |c| webrick_res.cookies << WEBrick::Cookie.parse_set_cookie(c) }
+                  else
+                    webrick_res[key] = value
+                  end
+                end
+
+                response_body = ""
+                body.each { |chunk| response_body += chunk }
+                webrick_res.body = response_body
+              end
+            end
+
+            define_method(:build_rack_env) do |req|
+              input = StringIO.new(req.body || "")
+              env = {
+                "REQUEST_METHOD"  => req.request_method,
+                "PATH_INFO"       => req.path,
+                "QUERY_STRING"    => req.query_string || "",
+                "SERVER_NAME"     => webrick_req_host,
+                "SERVER_PORT"     => webrick_req_port,
+                "CONTENT_TYPE"    => req.content_type || "",
+                "CONTENT_LENGTH"  => (req.content_length rescue 0).to_s,
+                "REMOTE_ADDR"     => req.peeraddr&.last || "127.0.0.1",
+                "rack.input"      => input,
+                "rack.errors"     => $stderr,
+                "rack.url_scheme" => "http",
+                "rack.version"    => [1, 3],
+                "rack.multithread"  => true,
+                "rack.multiprocess" => false,
+                "rack.run_once"     => false
+              }
+
+              req.header.each do |key, values|
+                env_key = "HTTP_#{key.upcase.gsub('-', '_')}"
+                env[env_key] = values.join(", ")
+              end
+
+              env
+            end
+          end
+
+          ai_servlet.define_method(:webrick_req_host) { ai_host }
+          ai_servlet.define_method(:webrick_req_port) { ai_port_str }
+
+          @ai_server.mount("/", ai_servlet, ai_rack_app)
+          @ai_thread = Thread.new { @ai_server.start }
+          puts "  AI Port:   http://localhost:#{ai_port} (no-reload)"
+        rescue Errno::EADDRINUSE
+          puts "  AI Port:   SKIPPED (port #{ai_port} in use)"
+        end
+      end
+
       @server.start
     end
 
     def stop
+      @ai_server&.shutdown
+      @ai_thread&.join(5)
       @server&.shutdown
     end
   end

data/lib/tina4.rb

@@ -59,6 +59,8 @@ module Tina4
     autoload :MysqlDriver,    File.expand_path("tina4/drivers/mysql_driver", __dir__)
     autoload :MssqlDriver,    File.expand_path("tina4/drivers/mssql_driver", __dir__)
     autoload :FirebirdDriver, File.expand_path("tina4/drivers/firebird_driver", __dir__)
+    autoload :MongodbDriver,  File.expand_path("tina4/drivers/mongodb_driver", __dir__)
+    autoload :OdbcDriver,     File.expand_path("tina4/drivers/odbc_driver", __dir__)
   end
 
   # ── Lazy-loaded: session handlers ─────────────────────────────────────

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: tina4ruby
 version: !ruby/object:Gem::Version
-  version: 3.10.50
+  version: 3.10.55
 platform: ruby
 authors:
 - Tina4 Team
@@ -294,8 +294,10 @@ files:
 - lib/tina4/dev_mailbox.rb
 - lib/tina4/dev_reload.rb
 - lib/tina4/drivers/firebird_driver.rb
+- lib/tina4/drivers/mongodb_driver.rb
 - lib/tina4/drivers/mssql_driver.rb
 - lib/tina4/drivers/mysql_driver.rb
+- lib/tina4/drivers/odbc_driver.rb
 - lib/tina4/drivers/postgres_driver.rb
 - lib/tina4/drivers/sqlite_driver.rb
 - lib/tina4/env.rb