tina4-python 3.10.0__tar.gz → 3.10.2__tar.gz

{tina4_python-3.10.0 → tina4_python-3.10.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tina4-python
-Version: 3.10.0
+Version: 3.10.2
 Summary: Tina4 Python v3 — Zero-dependency, lightweight web framework
 Author-email: Andre van Zuydam <andrevanzuydam@gmail.com>
 License: MIT

{tina4_python-3.10.0 → tina4_python-3.10.2}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "tina4-python"
-version = "3.10.0"
+version = "3.10.2"
 description = "Tina4 Python v3 — Zero-dependency, lightweight web framework"
 authors = [
     {name = "Andre van Zuydam", email = "andrevanzuydam@gmail.com"}

{tina4_python-3.10.0 → tina4_python-3.10.2}/tina4_python/core/router.py

@@ -180,10 +180,12 @@ class Router:
         if cls._group_prefix:
             path = cls._group_prefix + path
 
-        # Merge group middleware with route-level middleware
-        if cls._group_middleware:
-            route_mw = options.get("middleware", [])
-            options["middleware"] = list(cls._group_middleware) + list(route_mw)
+        # Merge group middleware with route-level middleware and handler-level middleware
+        handler_mw = getattr(handler, "_middleware", [])
+        route_mw = options.get("middleware", [])
+        combined_mw = list(cls._group_middleware) + list(handler_mw) + list(route_mw)
+        if combined_mw:
+            options["middleware"] = combined_mw
 
         pattern, param_names = _compile_pattern(path)
 
@@ -251,8 +253,14 @@ def _compile_pattern(path: str) -> tuple[re.Pattern, list[str]]:
     param_names = []
     regex_parts = []
 
-    for segment in path.strip("/").split("/"):
-        if segment.startswith("{") and segment.endswith("}"):
+    segments = path.strip("/").split("/")
+    for i, segment in enumerate(segments):
+        if segment == "*":
+            # Wildcard: matches the rest of the path (greedy)
+            param_names.append("wildcard")
+            regex_parts.append("(.+)")
+            break  # Nothing can follow a wildcard
+        elif segment.startswith("{") and segment.endswith("}"):
             inner = segment[1:-1]
             if ":" in inner:
                 name, type_hint = inner.split(":", 1)
@@ -277,51 +285,53 @@ def _compile_pattern(path: str) -> tuple[re.Pattern, list[str]]:
 
 # Decorator functions — the public API
 
+def _register_route(method: str, path: str, fn, **options):
+    """Common registration logic that preserves handler attributes on the returned ref."""
+    ref = Router.add(method, path, fn, **options)
+    # Propagate handler attributes to the wrapper so stacked decorators still work
+    fn._route_ref = ref
+    return fn
+
+
 def get(path: str, **options):
     """Register a GET route."""
     def decorator(fn):
-        Router.add("GET", path, fn, **options)
-        return fn
+        return _register_route("GET", path, fn, **options)
     return decorator
 
 
 def post(path: str, **options):
     """Register a POST route."""
     def decorator(fn):
-        Router.add("POST", path, fn, **options)
-        return fn
+        return _register_route("POST", path, fn, **options)
     return decorator
 
 
 def put(path: str, **options):
     """Register a PUT route."""
     def decorator(fn):
-        Router.add("PUT", path, fn, **options)
-        return fn
+        return _register_route("PUT", path, fn, **options)
     return decorator
 
 
 def patch(path: str, **options):
     """Register a PATCH route."""
     def decorator(fn):
-        Router.add("PATCH", path, fn, **options)
-        return fn
+        return _register_route("PATCH", path, fn, **options)
     return decorator
 
 
 def delete(path: str, **options):
     """Register a DELETE route."""
     def decorator(fn):
-        Router.add("DELETE", path, fn, **options)
-        return fn
+        return _register_route("DELETE", path, fn, **options)
     return decorator
 
 
 def any_method(path: str, **options):
     """Register a route for any HTTP method."""
     def decorator(fn):
-        Router.add("ANY", path, fn, **options)
-        return fn
+        return _register_route("ANY", path, fn, **options)
     return decorator
 
 # Alias — @any() is the standard name across all Tina4 frameworks
@@ -352,6 +362,10 @@ def noauth():
     """Make a write route (POST/PUT/PATCH/DELETE) public — no auth required."""
     def decorator(fn):
         fn._noauth = True
+        # If route was already registered (decorator applied after @get/@post),
+        # update the route dict directly.
+        if hasattr(fn, "_route_ref"):
+            fn._route_ref._route["auth_required"] = False
         return fn
     return decorator
 
@@ -360,6 +374,10 @@ def secured():
     """Require auth on a GET route (which is public by default)."""
     def decorator(fn):
         fn._secured = True
+        # If route was already registered (decorator applied after @get/@post),
+        # update the route dict directly.
+        if hasattr(fn, "_route_ref"):
+            fn._route_ref._route["auth_required"] = True
         return fn
     return decorator
 
@@ -370,6 +388,11 @@ def middleware(*middleware_classes):
     """Attach middleware classes to a route handler."""
     def decorator(fn):
         fn._middleware = list(middleware_classes)
+        # If route was already registered (decorator applied after @get/@post),
+        # update the route dict directly.
+        if hasattr(fn, "_route_ref"):
+            existing = fn._route_ref._route.get("middleware", [])
+            fn._route_ref._route["middleware"] = list(middleware_classes) + existing
         return fn
     return decorator
 

{tina4_python-3.10.0 → tina4_python-3.10.2}/tina4_python/core/server.py

@@ -772,40 +772,98 @@ async def app(scope: dict, receive, send):
         request._route_params = params
         request.merge_route_params()
         try:
-            import inspect
-            _sig = inspect.signature(route["handler"])
-            _params = list(_sig.parameters.values())
-            _pcount = len(_params)
-
-            # Build args: inject path params by name, then request/response
-            _args = []
-            _remaining = []
-            for p in _params:
-                name = p.name
-                if name in params:
-                    _args.append(params[name])
-                else:
-                    _remaining.append(p)
-
-            # Append request/response for remaining positional params
-            if len(_remaining) == 0:
-                pass  # All params were path params
-            elif len(_remaining) == 1:
-                _ann = _remaining[0].annotation
-                if _ann is Request or (isinstance(_ann, str) and _ann in ("Request", "request")):
+            # ── Auth enforcement ────────────────────────────────────
+            _skip_handler = False
+            if route.get("auth_required"):
+                _auth_header = request.headers.get("authorization", "")
+                _api_key = os.environ.get("TINA4_API_KEY", os.environ.get("API_KEY", ""))
+                _auth_ok = False
+                if _auth_header:
+                    if _auth_header.startswith("Bearer "):
+                        _token = _auth_header[7:]
+                        # Check static API key first
+                        if _api_key and _token == _api_key:
+                            _auth_ok = True
+                        else:
+                            # Validate JWT token
+                            try:
+                                from tina4_python.auth import Auth
+                                if Auth.valid_token(_token):
+                                    _auth_ok = True
+                            except Exception:
+                                pass
+                if not _auth_ok:
+                    response.status(401).json({
+                        "error": "Unauthorized",
+                        "message": "Valid authorization token required",
+                        "status": 401,
+                    })
+                    _skip_handler = True
+
+            # ── Route middleware (before_* methods) ─────────────────
+            if not _skip_handler:
+                for _mw_cls in route.get("middleware", []):
+                    _mw_inst = _mw_cls() if isinstance(_mw_cls, type) else _mw_cls
+                    for _attr_name in dir(_mw_inst):
+                        if _attr_name.startswith("before_"):
+                            _mw_method = getattr(_mw_inst, _attr_name)
+                            if callable(_mw_method):
+                                _mw_result = _mw_method(request, response)
+                                if _mw_result is not None:
+                                    request, response = _mw_result
+                                    # If middleware returned an error status, skip handler
+                                    if response.status_code >= 400:
+                                        _skip_handler = True
+                                        break
+                    if _skip_handler:
+                        break
+
+            if not _skip_handler:
+                import inspect
+                _sig = inspect.signature(route["handler"])
+                _params = list(_sig.parameters.values())
+                _pcount = len(_params)
+
+                # Build args: inject path params by name, then request/response
+                _args = []
+                _remaining = []
+                for p in _params:
+                    name = p.name
+                    if name in params:
+                        _args.append(params[name])
+                    else:
+                        _remaining.append(p)
+
+                # Append request/response for remaining positional params
+                if len(_remaining) == 0:
+                    pass  # All params were path params
+                elif len(_remaining) == 1:
+                    _ann = _remaining[0].annotation
+                    if _ann is Request or (isinstance(_ann, str) and _ann in ("Request", "request")):
+                        _args.append(request)
+                    else:
+                        _args.append(response)
+                elif len(_remaining) >= 2:
                     _args.append(request)
-                else:
                     _args.append(response)
-            elif len(_remaining) >= 2:
-                _args.append(request)
-                _args.append(response)
 
-            if _pcount == 0:
-                result = await route["handler"]()
-            else:
-                result = await route["handler"](*_args)
-            if isinstance(result, Response):
-                response = result
+                if _pcount == 0:
+                    result = await route["handler"]()
+                else:
+                    result = await route["handler"](*_args)
+                if isinstance(result, Response):
+                    response = result
+
+            # ── Route middleware (after_* methods) ──────────────────
+            for _mw_cls in route.get("middleware", []):
+                _mw_inst = _mw_cls() if isinstance(_mw_cls, type) else _mw_cls
+                for _attr_name in dir(_mw_inst):
+                    if _attr_name.startswith("after_"):
+                        _mw_method = getattr(_mw_inst, _attr_name)
+                        if callable(_mw_method):
+                            _mw_result = _mw_method(request, response)
+                            if _mw_result is not None:
+                                request, response = _mw_result
         except Exception as e:
             Log.error(f"Route error: {e}", path=request.path)
             _write_broken(request, e)
@@ -1135,6 +1193,11 @@ def run(host: str | None = None, port: int | None = None):
     global _start_time
     _start_time = time.time()
 
+    # Ensure CWD is on sys.path so auto-discovered modules can be imported
+    cwd = os.getcwd()
+    if cwd not in sys.path:
+        sys.path.insert(0, cwd)
+
     # Load .env first so env vars are available for logger init
     from tina4_python.dotenv import load_env
     load_env()

{tina4_python-3.10.0 → tina4_python-3.10.2}/tina4_python/database/connection.py

@@ -36,12 +36,13 @@ class ConnectionPool:
     """
 
     def __init__(self, pool_size: int, factory: callable, connect_path: str,
-                 username: str = "", password: str = ""):
+                 username: str = "", password: str = "", **kwargs):
         self._pool_size = pool_size
         self._factory = factory
         self._connect_path = connect_path
         self._username = username
         self._password = password
+        self._connect_kwargs = kwargs
         self._adapters: list[DatabaseAdapter | None] = [None] * pool_size
         self._index = 0
         self._lock = threading.Lock()
@@ -50,7 +51,7 @@ class ConnectionPool:
         """Lazily create an adapter at the given index."""
         if self._adapters[idx] is None:
             adapter = self._factory()
-            adapter.connect(self._connect_path, username=self._username, password=self._password)
+            adapter.connect(self._connect_path, username=self._username, password=self._password, **self._connect_kwargs)
             self._adapters[idx] = adapter
         return self._adapters[idx]
 
@@ -130,12 +131,13 @@ class Database:
     operations to the adapter. This is what the rest of the framework uses.
     """
 
-    def __init__(self, url: str = None, username: str = "", password: str = "", pool: int = 0):
+    def __init__(self, url: str = None, username: str = "", password: str = "", pool: int = 0, **kwargs):
         self.url = url or os.environ.get("DATABASE_URL", "sqlite:///data/tina4.db")
         # Priority: constructor params > env vars > empty
         self.username = username or os.environ.get("DATABASE_USERNAME", "")
         self.password = password or os.environ.get("DATABASE_PASSWORD", "")
         self.pool_size = pool  # 0 = single connection, N>0 = N pooled connections
+        self._connect_kwargs = kwargs  # Extra kwargs passed through to adapter.connect()
 
         if self.pool_size > 0:
             # Pooled mode — create a ConnectionPool with lazy adapter creation
@@ -145,13 +147,14 @@ class Database:
                 connect_path=self._connection_path(),
                 username=self.username,
                 password=self.password,
+                **kwargs,
             )
             self._adapter: DatabaseAdapter | None = None
         else:
             # Single-connection mode — current behavior
             self._pool: ConnectionPool | None = None
             self._adapter: DatabaseAdapter = self._create_adapter()
-            self._adapter.connect(self._connection_path(), username=self.username, password=self.password)
+            self._adapter.connect(self._connection_path(), username=self.username, password=self.password, **kwargs)
 
         # Query cache — off by default, opt-in via TINA4_DB_CACHE=true
         from tina4_python.dotenv import is_truthy

{tina4_python-3.10.0 → tina4_python-3.10.2}/tina4_python/database/firebird.py

@@ -1,18 +1,32 @@
-# Tina4 Firebird Driver — Uses fdb (optional).
+# Tina4 Firebird Driver — Uses firebird-driver or fdb (optional).
 """
-Firebird adapter using fdb.
+Firebird adapter using firebird-driver (preferred) or fdb (fallback).
 
     db = Database("firebird://user:pass@localhost:3050/path/to/database.fdb")
 
-Requires: pip install fdb
+Requires: pip install firebird-driver  (or pip install fdb for legacy)
 """
 import re
 from urllib.parse import urlparse, unquote
 from tina4_python.database.adapter import DatabaseAdapter, DatabaseResult, SQLTranslator
 
+# Try modern firebird-driver first, fall back to legacy fdb
+_driver = None
+_driver_name = None
+try:
+    import firebird.driver as _driver
+    _driver_name = "firebird-driver"
+except ImportError:
+    try:
+        import fdb as _driver
+        _driver_name = "fdb"
+    except ImportError:
+        _driver = None
+        _driver_name = None
+
 
 class FirebirdAdapter(DatabaseAdapter):
-    """Firebird database driver using fdb."""
+    """Firebird database driver using firebird-driver or fdb."""
 
     def __init__(self):
         super().__init__()
@@ -25,12 +39,10 @@ class FirebirdAdapter(DatabaseAdapter):
         Connection string: firebird://user:pass@host:port/path/to/db.fdb
         Credentials priority: URL > username/password params > adapter defaults (SYSDBA/masterkey).
         """
-        try:
-            import fdb
-        except ImportError:
+        if _driver is None:
             raise ImportError(
-                "fdb is required for Firebird connections. "
-                "Install: pip install fdb"
+                "A Firebird driver is required. "
+                "Install: pip install firebird-driver  (or pip install fdb for legacy)"
             )
 
         parsed = urlparse(connection_string)
@@ -42,15 +54,27 @@ class FirebirdAdapter(DatabaseAdapter):
         password = parsed.password or password or "masterkey"
         charset = kwargs.pop("charset", "UTF8")
 
-        self._conn = fdb.connect(
-            host=host,
-            port=port,
-            database=db_path,
-            user=user,
-            password=password,
-            charset=charset,
-            **kwargs,
-        )
+        if _driver_name == "firebird-driver":
+            # Modern firebird-driver uses dsn format: host/port:path
+            dsn = f"{host}/{port}:{db_path}" if port != 3050 else f"{host}:{db_path}"
+            self._conn = _driver.connect(
+                dsn,
+                user=user,
+                password=password,
+                charset=charset,
+                **kwargs,
+            )
+        else:
+            # Legacy fdb
+            self._conn = _driver.connect(
+                host=host,
+                port=port,
+                database=db_path,
+                user=user,
+                password=password,
+                charset=charset,
+                **kwargs,
+            )
 
     def close(self):
         if self._conn:
@@ -94,7 +118,7 @@ class FirebirdAdapter(DatabaseAdapter):
                         desc = cursor.description
                         row = cursor.fetchone()
                         if row and desc:
-                            col_names = [d[0] for d in desc]
+                            col_names = [d[0].strip().lower() for d in desc]
                             records = [dict(zip(col_names, row))]
                 except Exception:
                     pass
@@ -133,7 +157,7 @@ class FirebirdAdapter(DatabaseAdapter):
         cursor.execute(paginated_sql, params or [])
 
         desc = cursor.description
-        col_names = [d[0] for d in desc] if desc else []
+        col_names = [d[0].strip().lower() for d in desc] if desc else []
         rows = [dict(zip(col_names, row)) for row in cursor.fetchall()]
 
         return DatabaseResult(records=rows, count=total, sql=sql, adapter=self)
@@ -146,7 +170,7 @@ class FirebirdAdapter(DatabaseAdapter):
         row = cursor.fetchone()
         if row is None:
             return None
-        col_names = [d[0] for d in desc] if desc else []
+        col_names = [d[0].strip().lower() for d in desc] if desc else []
         return dict(zip(col_names, row))
 
     def insert(self, table: str, data: dict) -> DatabaseResult:
@@ -204,7 +228,7 @@ class FirebirdAdapter(DatabaseAdapter):
             "ORDER BY RDB$RELATION_NAME",
             limit=10000,
         )
-        return [r["RDB$RELATION_NAME"].strip() for r in result.records]
+        return [r["rdb$relation_name"].strip() for r in result.records]
 
     def get_columns(self, table: str) -> list[dict]:
         sql = (
@@ -224,10 +248,10 @@ class FirebirdAdapter(DatabaseAdapter):
         }
         return [
             {
-                "name": r["RDB$FIELD_NAME"].strip() if r["RDB$FIELD_NAME"] else "",
-                "type": type_map.get(r.get("RDB$FIELD_TYPE"), str(r.get("RDB$FIELD_TYPE", ""))),
-                "nullable": r.get("RDB$NULL_FLAG") is None,
-                "default": r.get("RDB$DEFAULT_SOURCE"),
+                "name": r["rdb$field_name"].strip() if r["rdb$field_name"] else "",
+                "type": type_map.get(r.get("rdb$field_type"), str(r.get("rdb$field_type", ""))),
+                "nullable": r.get("rdb$null_flag") is None,
+                "default": r.get("rdb$default_source"),
                 "primary_key": False,
             }
             for r in result.records

{tina4_python-3.10.0 → tina4_python-3.10.2}/tina4_python/frond/engine.py

@@ -217,21 +217,52 @@ def _resolve(expr: str, context: dict):
     for part in parts:
         if part.startswith("[") and part.endswith("]"):
             idx = part[1:-1].strip("'\"")
-            try:
-                idx = int(idx)
-            except ValueError:
-                pass
-            try:
-                value = value[idx]
-            except (KeyError, IndexError, TypeError):
-                return None
-        elif isinstance(value, dict):
-            value = value.get(part)
-        elif hasattr(value, part):
-            attr = getattr(value, part)
-            value = attr() if callable(attr) else attr
+            # Slice syntax: value[1:5], value[:10], value[3:]
+            if ":" in idx:
+                slice_parts = idx.split(":", 1)
+                s_start = int(slice_parts[0]) if slice_parts[0].strip() else None
+                s_end = int(slice_parts[1]) if slice_parts[1].strip() else None
+                try:
+                    value = value[s_start:s_end]
+                except (TypeError, IndexError):
+                    return None
+            else:
+                try:
+                    idx = int(idx)
+                except ValueError:
+                    pass
+                try:
+                    value = value[idx]
+                except (KeyError, IndexError, TypeError):
+                    return None
         else:
-            return None
+            # Check if this part is a method call: name(args)
+            call_match = re.match(r"^(\w+)\s*\((.*)?\)$", part, re.DOTALL)
+            if call_match:
+                method_name = call_match.group(1)
+                raw_args = call_match.group(2) or ""
+                # Resolve the callable from the current value
+                if isinstance(value, dict):
+                    fn = value.get(method_name)
+                elif hasattr(value, method_name):
+                    fn = getattr(value, method_name)
+                else:
+                    return None
+                if callable(fn):
+                    if raw_args.strip():
+                        args = [_eval_expr(a.strip(), context) for a in _split_args(raw_args)]
+                    else:
+                        args = []
+                    value = fn(*args)
+                else:
+                    return None
+            elif isinstance(value, dict):
+                value = value.get(part)
+            elif hasattr(value, part):
+                attr = getattr(value, part)
+                value = attr() if callable(attr) else attr
+            else:
+                return None
 
         if value is None:
             return None
@@ -239,6 +270,35 @@ def _resolve(expr: str, context: dict):
     return value
 
 
+def _split_args(raw: str) -> list[str]:
+    """Split comma-separated arguments respecting quotes and nested parens."""
+    parts = []
+    current = ""
+    in_q = None
+    depth = 0
+    for ch in raw:
+        if ch in ('"', "'") and not in_q:
+            in_q = ch
+            current += ch
+        elif ch == in_q:
+            in_q = None
+            current += ch
+        elif ch == "(" and not in_q:
+            depth += 1
+            current += ch
+        elif ch == ")" and not in_q:
+            depth -= 1
+            current += ch
+        elif ch == "," and not in_q and depth == 0:
+            parts.append(current.strip())
+            current = ""
+        else:
+            current += ch
+    if current.strip():
+        parts.append(current.strip())
+    return parts
+
+
 def _eval_expr(expr: str, context: dict):
     """Evaluate a full expression (with ~, ternary, ??, comparisons)."""
     expr = expr.strip()

{tina4_python-3.10.0 → tina4_python-3.10.2}/tina4_python/migration/runner.py

@@ -18,7 +18,11 @@ logger = logging.getLogger(__name__)
 
 
 def _ensure_tracking_table(db):
-    """Create the migration tracking table if it doesn't exist."""
+    """Create or upgrade the migration tracking table.
+
+    Handles v2→v3 upgrade: v2 tables have `description` but no `migration_id`.
+    When detected, adds the missing column and backfills from `description`.
+    """
     if not db.table_exists("tina4_migration"):
         db.execute("""
             CREATE TABLE tina4_migration (
@@ -31,15 +35,62 @@ def _ensure_tracking_table(db):
             )
         """)
         db.commit()
+        return
+
+    # Check if this is a v2 table (has description but no migration_id column)
+    try:
+        db.fetch_one("SELECT migration_id FROM tina4_migration WHERE 1=0")
+    except Exception:
+        # migration_id column doesn't exist — v2 schema, upgrade it
+        try:
+            db.execute("ALTER TABLE tina4_migration ADD migration_id TEXT")
+            db.commit()
+        except Exception:
+            pass  # Column may already exist on some engines
+
+        # Backfill migration_id from description (v2 used description as the identifier)
+        try:
+            db.execute("UPDATE tina4_migration SET migration_id = description WHERE migration_id IS NULL")
+            db.commit()
+        except Exception:
+            pass
+
+        # Add batch column if missing (v2 didn't have it)
+        try:
+            db.fetch_one("SELECT batch FROM tina4_migration WHERE 1=0")
+        except Exception:
+            try:
+                db.execute("ALTER TABLE tina4_migration ADD batch INTEGER DEFAULT 1")
+                db.commit()
+            except Exception:
+                pass
+
+        # Add executed_at column if missing
+        try:
+            db.fetch_one("SELECT executed_at FROM tina4_migration WHERE 1=0")
+        except Exception:
+            try:
+                db.execute("ALTER TABLE tina4_migration ADD executed_at TEXT DEFAULT ''")
+                db.commit()
+            except Exception:
+                pass
 
 
 def _get_executed(db) -> set[str]:
     """Get set of already-executed migration IDs."""
-    result = db.fetch(
-        "SELECT migration_id FROM tina4_migration WHERE passed = 1",
-        limit=10000,
-    )
-    return {row["migration_id"] for row in result.records}
+    try:
+        result = db.fetch(
+            "SELECT migration_id FROM tina4_migration WHERE passed = 1",
+            limit=10000,
+        )
+        return {row["migration_id"] for row in result.records if row.get("migration_id")}
+    except Exception:
+        # Fallback for v2 tables where migration_id may not exist yet
+        result = db.fetch(
+            "SELECT description FROM tina4_migration WHERE passed = 1",
+            limit=10000,
+        )
+        return {row["description"] for row in result.records if row.get("description")}
 
 
 def _get_next_batch(db) -> int:

{tina4_python-3.10.0 → tina4_python-3.10.2}/tina4_python/orm/model.py

@@ -43,6 +43,22 @@ def orm_bind(db, name: str = None):
         _databases[name] = db
 
 
+def snake_to_camel(name: str) -> str:
+    """Convert snake_case to camelCase: 'first_name' -> 'firstName'."""
+    parts = name.split("_")
+    return parts[0] + "".join(p.capitalize() for p in parts[1:])
+
+
+def camel_to_snake(name: str) -> str:
+    """Convert camelCase to snake_case: 'firstName' -> 'first_name'."""
+    result = []
+    for c in name:
+        if c.isupper() and result:
+            result.append("_")
+        result.append(c.lower())
+    return "".join(result)
+
+
 class ORMMeta(type):
     """Metaclass that collects Field definitions and relationship descriptors."""
 
@@ -79,6 +95,7 @@ class ORM(metaclass=ORMMeta):
     table_name: str = ""
     soft_delete: bool = False  # Set True to enable soft delete
     field_mapping: dict[str, str] = {}  # {"python_attribute": "db_column"}
+    auto_map: bool = False  # No-op in Python (snake_case matches DB); exists for cross-language parity
     _db: str | object | None = None  # Per-model database override
     _fields: dict[str, Field] = {}