ferro-orm 0.10.1__tar.gz → 0.10.2__tar.gz

{ferro_orm-0.10.1 → ferro_orm-0.10.2}/CHANGELOG.md

@@ -1,6 +1,15 @@
 # CHANGELOG
 
 
+## v0.10.2 (2026-05-19)
+
+### Bug Fixes
+
+- Hydrate SQLite INTEGER-backed Decimal columns on reconnect
+  ([#59](https://github.com/syn54x/ferro-orm/pull/59),
+  [`6f13906`](https://github.com/syn54x/ferro-orm/commit/6f13906850300bc9e85c1274763c49bc5b318b5d))
+
+
 ## v0.10.1 (2026-05-19)
 
 ### Bug Fixes

{ferro_orm-0.10.1 → ferro_orm-0.10.2}/Cargo.lock

@@ -294,7 +294,7 @@ dependencies = [
 
 [[package]]
 name = "ferro"
-version = "0.10.1"
+version = "0.10.2"
 dependencies = [
  "dashmap",
  "once_cell",

{ferro_orm-0.10.1 → ferro_orm-0.10.2}/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "ferro"
-version = "0.10.1"
+version = "0.10.2"
 edition = "2024"
 readme = "README.md"
 

{ferro_orm-0.10.1 → ferro_orm-0.10.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ferro-orm
-Version: 0.10.1
+Version: 0.10.2
 Requires-Dist: pydantic>=2.0
 Requires-Dist: alembic>=1.18.1 ; extra == 'alembic'
 Requires-Dist: sqlalchemy>=2.0.46 ; extra == 'alembic'

{ferro_orm-0.10.1 → ferro_orm-0.10.2}/docs/solutions/issues/sqlite-null-hydrates-as-int-zero.md

@@ -5,7 +5,7 @@ tags: [gotcha, sqlite, hydration, bridge, rust, sqlalchemy, alembic, datetime, f
 related_files:
   - src/backend.rs
   - src/operations.rs
-  - tests/test_sqlite_null_hydration.py
+  - tests/test_sqlite_alembic_reconnect_hydration.py
 related_issues: [56]
 related_prs: [57]
 captured: 2026-05-18
@@ -62,7 +62,7 @@ by treating `0` as missing.
 
 - Rust: `engine_handle_fetches_sqlite_null_columns_as_null_not_zero`,
   `engine_handle_fetches_sqlite_non_null_zero_integer` in `src/backend.rs`.
-- Python: `tests/test_sqlite_null_hydration.py` (Alembic `create_all` + reconnect).
+- Python: `tests/test_sqlite_alembic_reconnect_hydration.py` (Alembic `create_all` + reconnect).
   Requires `aiosqlite` and `greenlet` in `ci-test` / `dev` so CI does not skip.
 
 ## How to recognize

{ferro_orm-0.10.1 → ferro_orm-0.10.2}/docs/solutions/patterns/typed-null-binds.md

@@ -7,7 +7,7 @@ related_files:
   - src/operations.rs
   - src/query.rs
   - tests/test_typed_null_binds.py
-  - tests/test_sqlite_null_hydration.py
+  - tests/test_sqlite_alembic_reconnect_hydration.py
 related_issues: [38, 40, 56]
 related_prs: []
 captured: 2026-04-29
@@ -112,7 +112,7 @@ typed `try_get`. Non-null integer `0` is unchanged; only SQL `NULL` is affected.
 | Fetch (read)     | `materialize_engine_row`     | `is_null()` before `decode_non_null_*`|
 
 Rust regression: `engine_handle_fetches_sqlite_null_columns_as_null_not_zero`.
-Integration: `tests/test_sqlite_null_hydration.py` (Alembic schema + reconnect).
+Integration: `tests/test_sqlite_alembic_reconnect_hydration.py` (Alembic schema + reconnect).
 
 ## Raw-SQL boundary (explicit exception)
 

{ferro_orm-0.10.1 → ferro_orm-0.10.2}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "ferro-orm"
-version = "0.10.1"
+version = "0.10.2"
 description = "A high-performance, Rust-backed ORM for Python."
 readme = "README.md"
 authors = [

{ferro_orm-0.10.1 → ferro_orm-0.10.2}/src/operations.rs

@@ -193,6 +193,7 @@ fn engine_value_to_rust_value(
 
     if is_decimal {
         return match value {
+            EngineValue::I64(v) => RustValue::Decimal(v.to_string()),
             EngineValue::F64(v) => RustValue::Decimal(v.to_string()),
             EngineValue::String(v) => RustValue::Decimal(v),
             _ => RustValue::None,
@@ -3077,3 +3078,125 @@ mod raw_sql_tests {
         });
     }
 }
+
+#[cfg(test)]
+mod engine_value_to_rust_value_tests {
+    use super::engine_value_to_rust_value;
+    use crate::backend::EngineValue;
+    use crate::state::RustValue;
+
+    fn decimal_schema() -> serde_json::Value {
+        serde_json::json!({
+            "properties": {
+                "hours": {
+                    "format": "decimal",
+                    "anyOf": [
+                        {"type": "number"},
+                        {"type": "string", "pattern": "^-?\\d+(\\.\\d+)?$"}
+                    ]
+                }
+            }
+        })
+    }
+
+    #[test]
+    fn decimal_column_maps_sqlite_integer_affinity_to_decimal() {
+        let schema = decimal_schema();
+        let out = engine_value_to_rust_value(EngineValue::I64(3), &schema, "hours");
+        assert!(matches!(out, RustValue::Decimal(ref s) if s == "3"));
+    }
+
+    #[test]
+    fn decimal_column_maps_real_and_text() {
+        let schema = decimal_schema();
+        let from_real =
+            engine_value_to_rust_value(EngineValue::F64(1.5), &schema, "hours");
+        assert!(matches!(from_real, RustValue::Decimal(ref s) if s == "1.5"));
+        let from_text =
+            engine_value_to_rust_value(EngineValue::String("2.25".into()), &schema, "hours");
+        assert!(matches!(from_text, RustValue::Decimal(ref s) if s == "2.25"));
+    }
+
+    fn datetime_schema() -> serde_json::Value {
+        serde_json::json!({
+            "properties": {
+                "happened_at": {"type": "string", "format": "date-time"}
+            }
+        })
+    }
+
+    fn binary_schema() -> serde_json::Value {
+        serde_json::json!({
+            "properties": {
+                "data": {"type": "string", "format": "binary"}
+            }
+        })
+    }
+
+    fn bool_schema() -> serde_json::Value {
+        serde_json::json!({
+            "properties": {
+                "is_active": {"type": "boolean"}
+            }
+        })
+    }
+
+    fn json_schema() -> serde_json::Value {
+        serde_json::json!({
+            "properties": {
+                "payload": {"type": "object"}
+            }
+        })
+    }
+
+    #[test]
+    fn datetime_column_only_accepts_string_engine_values() {
+        let schema = datetime_schema();
+        let ok = engine_value_to_rust_value(
+            EngineValue::String("2026-04-24T18:30:00+00:00".into()),
+            &schema,
+            "happened_at",
+        );
+        assert!(matches!(ok, RustValue::DateTime(_)));
+        let from_int = engine_value_to_rust_value(EngineValue::I64(1713984600), &schema, "happened_at");
+        assert!(matches!(from_int, RustValue::BigInt(1713984600)));
+    }
+
+    #[test]
+    fn binary_column_maps_bytes_and_text() {
+        let schema = binary_schema();
+        let from_bytes =
+            engine_value_to_rust_value(EngineValue::Bytes(vec![1, 2, 3]), &schema, "data");
+        assert!(matches!(from_bytes, RustValue::Blob(v) if v == vec![1, 2, 3]));
+        let from_text =
+            engine_value_to_rust_value(EngineValue::String("abc".into()), &schema, "data");
+        assert!(matches!(from_text, RustValue::Blob(v) if v == b"abc".to_vec()));
+        let from_int = engine_value_to_rust_value(EngineValue::I64(1), &schema, "data");
+        assert!(matches!(from_int, RustValue::None));
+    }
+
+    #[test]
+    fn bool_column_maps_integer_and_bool() {
+        let schema = bool_schema();
+        assert!(matches!(
+            engine_value_to_rust_value(EngineValue::I64(1), &schema, "is_active"),
+            RustValue::Bool(true)
+        ));
+        assert!(matches!(
+            engine_value_to_rust_value(EngineValue::Bool(false), &schema, "is_active"),
+            RustValue::Bool(false)
+        ));
+    }
+
+    #[test]
+    fn json_column_parses_string_payload() {
+        let schema = json_schema();
+        let out = engine_value_to_rust_value(
+            EngineValue::String(r#"{"k":"v"}"#.into()),
+            &schema,
+            "payload",
+        );
+        assert!(matches!(out, RustValue::Json(v) if v.get("k").and_then(|x| x.as_str()) == Some("v")));
+    }
+
+}

ferro_orm-0.10.2/tests/test_sqlite_alembic_reconnect_hydration.py

@@ -0,0 +1,272 @@
+"""SQLite + Alembic schema: typed column hydration after reset_engine() / reconnect.
+
+Most Ferro tests use auto_migrate=True (Rust DDL) and same-session reads (identity map).
+Bugs like #56 (NULL -> int 0) and #58 (INTEGER Decimal -> None) only appear when:
+
+- Schema comes from Alembic ``create_all`` (``auto_migrate=False``)
+- Rows are re-fetched on a fresh ``ferro.connect()``
+"""
+
+from __future__ import annotations
+
+import json
+import sqlite3
+import tempfile
+from collections.abc import AsyncIterator
+from contextlib import asynccontextmanager
+from datetime import UTC, date, datetime
+from decimal import Decimal
+from pathlib import Path
+from typing import Any
+from uuid import UUID, uuid4
+
+import ferro
+import pytest
+from ferro import Field, Model, clear_registry, reset_engine
+from ferro.migrations.alembic import get_metadata
+from sqlalchemy import pool
+from sqlalchemy.engine.url import URL
+from sqlalchemy.ext.asyncio import create_async_engine
+
+pytest.importorskip("aiosqlite")
+pytest.importorskip("greenlet")
+
+pytestmark = pytest.mark.sqlite_only
+
+
+@pytest.fixture(autouse=True)
+def cleanup() -> None:
+    from ferro.state import _JOIN_TABLE_REGISTRY, _MODEL_REGISTRY_PY, _PENDING_RELATIONS
+
+    _MODEL_REGISTRY_PY.clear()
+    _PENDING_RELATIONS.clear()
+    _JOIN_TABLE_REGISTRY.clear()
+    reset_engine()
+    clear_registry()
+    yield
+
+
+def _sqlite_url(path: Path) -> str:
+    return URL.create(
+        drivername="sqlite+aiosqlite",
+        database=str(path.resolve()),
+    ).render_as_string(hide_password=False)
+
+
+@asynccontextmanager
+async def _alembic_sqlite_db() -> AsyncIterator[tuple[str, Path]]:
+    with tempfile.TemporaryDirectory() as tmp:
+        db_path = Path(tmp) / "app.db"
+        uri = f"sqlite:{db_path}?mode=rwc"
+        engine = create_async_engine(_sqlite_url(db_path), poolclass=pool.NullPool)
+        async with engine.begin() as conn:
+            await conn.run_sync(lambda sync_conn: get_metadata().create_all(sync_conn))
+        await engine.dispose()
+        yield uri, db_path
+
+
+async def _reload_row[M: Model](model: type[M], uri: str, row_id: str) -> M:
+    reset_engine()
+    await ferro.connect(uri, auto_migrate=False)
+    row = await model.where(model.id == row_id).first()  # type: ignore[attr-defined]
+    assert row is not None
+    return row
+
+
+def _sqlite_typeof(db_path: Path, table: str, column: str, row_id: str) -> tuple[Any, str]:
+    with sqlite3.connect(db_path) as conn:
+        value, affinity = conn.execute(
+            f"SELECT {column}, typeof({column}) FROM {table} WHERE id = ?",
+            (row_id,),
+        ).fetchone()
+    return value, affinity
+
+
+@pytest.mark.asyncio
+async def test_null_optional_datetime_is_none_not_zero() -> None:
+    """Issue #56: NULL DATETIME must not hydrate as int(0)."""
+
+    class Client(Model):
+        id: str = Field(default_factory=lambda: str(uuid4()), primary_key=True, db_type="text")
+        name: str
+        archived_at: datetime | None = None
+
+    async with _alembic_sqlite_db() as (uri, db_path):
+        await ferro.connect(uri, auto_migrate=False)
+        created = await Client.create(name="Acme")
+        row = await _reload_row(Client, uri, created.id)
+        raw, affinity = _sqlite_typeof(db_path, "client", "archived_at", created.id)
+
+    assert raw is None
+    assert row.archived_at is None
+
+
+@pytest.mark.asyncio
+async def test_non_null_datetime_round_trips() -> None:
+    class Event(Model):
+        id: str = Field(default_factory=lambda: str(uuid4()), primary_key=True, db_type="text")
+        happened_at: datetime = Field(default_factory=lambda: datetime(2026, 4, 24, 18, 30, tzinfo=UTC))
+
+    async with _alembic_sqlite_db() as (uri, db_path):
+        await ferro.connect(uri, auto_migrate=False)
+        expected = datetime(2026, 4, 24, 18, 30, tzinfo=UTC)
+        created = await Event.create(happened_at=expected)
+        row = await _reload_row(Event, uri, created.id)
+        _sqlite_typeof(db_path, "event", "happened_at", created.id)
+
+    assert row.happened_at == expected
+
+
+@pytest.mark.asyncio
+async def test_non_null_date_round_trips() -> None:
+    class Day(Model):
+        id: str = Field(default_factory=lambda: str(uuid4()), primary_key=True, db_type="text")
+        on_date: date
+
+    async with _alembic_sqlite_db() as (uri, db_path):
+        await ferro.connect(uri, auto_migrate=False)
+        expected = date(2026, 4, 24)
+        created = await Day.create(on_date=expected)
+        row = await _reload_row(Day, uri, created.id)
+        _sqlite_typeof(db_path, "day", "on_date", created.id)
+
+    assert row.on_date == expected
+
+
+@pytest.mark.asyncio
+@pytest.mark.parametrize(
+    ("hours", "expected"),
+    [
+        (Decimal(3), Decimal(3)),
+        (Decimal("1.5"), Decimal("1.5")),
+        (Decimal("0"), Decimal("0")),
+    ],
+    ids=["integer_affinity", "real_affinity", "decimal_zero"],
+)
+async def test_decimal_round_trips(hours: Decimal, expected: Decimal) -> None:
+    """Issue #58 class: NUMERIC columns must survive SQLite affinity + reconnect."""
+
+    class Widget(Model):
+        id: str = Field(default_factory=lambda: str(uuid4()), primary_key=True, db_type="text")
+        hours: Decimal
+
+    async with _alembic_sqlite_db() as (uri, db_path):
+        await ferro.connect(uri, auto_migrate=False)
+        created = await Widget.create(hours=hours)
+        row = await _reload_row(Widget, uri, created.id)
+        raw, affinity = _sqlite_typeof(db_path, "widget", "hours", created.id)
+
+    assert row.hours == expected
+    if hours == Decimal(3):
+        assert raw == 3
+        assert affinity == "integer"
+
+
+@pytest.mark.asyncio
+async def test_decimal_string_literal_round_trips() -> None:
+    """String INSERT into NUMERIC may coerce affinity; value must still hydrate."""
+
+    class Widget(Model):
+        id: str = Field(default_factory=lambda: str(uuid4()), primary_key=True, db_type="text")
+        hours: Decimal
+
+    row_id = str(uuid4())
+    async with _alembic_sqlite_db() as (uri, db_path):
+        with sqlite3.connect(db_path) as conn:
+            conn.execute(
+                "INSERT INTO widget (id, hours) VALUES (?, ?)",
+                (row_id, "12.34"),
+            )
+        await ferro.connect(uri, auto_migrate=False)
+        row = await _reload_row(Widget, uri, row_id)
+        raw, affinity = _sqlite_typeof(db_path, "widget", "hours", row_id)
+
+    assert row.hours == Decimal("12.34")
+    assert affinity in ("text", "real")
+    assert raw in ("12.34", 12.34)
+
+
+@pytest.mark.asyncio
+async def test_optional_decimal_null_is_none() -> None:
+    class Line(Model):
+        id: str = Field(default_factory=lambda: str(uuid4()), primary_key=True, db_type="text")
+        amount: Decimal | None = None
+
+    async with _alembic_sqlite_db() as (uri, db_path):
+        await ferro.connect(uri, auto_migrate=False)
+        created = await Line.create()
+        row = await _reload_row(Line, uri, created.id)
+        raw, _ = _sqlite_typeof(db_path, "line", "amount", created.id)
+
+    assert raw is None
+    assert row.amount is None
+
+
+@pytest.mark.asyncio
+async def test_bool_round_trips() -> None:
+    class Flag(Model):
+        id: str = Field(default_factory=lambda: str(uuid4()), primary_key=True, db_type="text")
+        is_active: bool
+
+    async with _alembic_sqlite_db() as (uri, db_path):
+        await ferro.connect(uri, auto_migrate=False)
+        created = await Flag.create(is_active=True)
+        row = await _reload_row(Flag, uri, created.id)
+        raw, affinity = _sqlite_typeof(db_path, "flag", "is_active", created.id)
+
+    assert row.is_active is True
+    assert raw in (1, True)
+    assert affinity == "integer"
+
+
+@pytest.mark.asyncio
+async def test_uuid_round_trips() -> None:
+    class Token(Model):
+        id: str = Field(default_factory=lambda: str(uuid4()), primary_key=True, db_type="text")
+        subject_id: UUID
+
+    token = uuid4()
+    async with _alembic_sqlite_db() as (uri, db_path):
+        await ferro.connect(uri, auto_migrate=False)
+        created = await Token.create(subject_id=token)
+        row = await _reload_row(Token, uri, created.id)
+        _sqlite_typeof(db_path, "token", "subject_id", created.id)
+
+    assert row.subject_id == token
+
+
+@pytest.mark.asyncio
+async def test_json_dict_round_trips() -> None:
+    class Doc(Model):
+        id: str = Field(default_factory=lambda: str(uuid4()), primary_key=True, db_type="text")
+        payload: dict[str, str]
+
+    data = {"k": "v", "n": "2"}
+    async with _alembic_sqlite_db() as (uri, db_path):
+        await ferro.connect(uri, auto_migrate=False)
+        created = await Doc.create(payload=data)
+        row = await _reload_row(Doc, uri, created.id)
+        raw, affinity = _sqlite_typeof(db_path, "doc", "payload", created.id)
+
+    assert row.payload == data
+    assert affinity == "text"
+    assert json.loads(raw) == data
+
+
+@pytest.mark.asyncio
+async def test_non_null_int_zero_round_trips() -> None:
+    """Legitimate integer 0 must not be confused with NULL (#56 regression guard)."""
+
+    class Counter(Model):
+        id: str = Field(default_factory=lambda: str(uuid4()), primary_key=True, db_type="text")
+        score: int
+
+    async with _alembic_sqlite_db() as (uri, db_path):
+        await ferro.connect(uri, auto_migrate=False)
+        created = await Counter.create(score=0)
+        row = await _reload_row(Counter, uri, created.id)
+        raw, affinity = _sqlite_typeof(db_path, "counter", "score", created.id)
+
+    assert row.score == 0
+    assert raw == 0
+    assert affinity == "integer"

ferro_orm-0.10.1/tests/test_sqlite_null_hydration.py

@@ -1,71 +0,0 @@
-"""SQLite NULL columns must hydrate as None, not int 0 (issue #56)."""
-
-from __future__ import annotations
-
-import sqlite3
-import tempfile
-from datetime import datetime
-from pathlib import Path
-from uuid import uuid4
-
-import ferro
-import pytest
-from ferro import Field, Model, clear_registry, reset_engine
-from ferro.migrations.alembic import get_metadata
-from sqlalchemy import pool
-from sqlalchemy.engine.url import URL
-from sqlalchemy.ext.asyncio import create_async_engine
-
-pytest.importorskip("aiosqlite")
-pytest.importorskip("greenlet")
-
-
-@pytest.fixture(autouse=True)
-def cleanup():
-    from ferro.state import _JOIN_TABLE_REGISTRY, _MODEL_REGISTRY_PY, _PENDING_RELATIONS
-
-    _MODEL_REGISTRY_PY.clear()
-    _PENDING_RELATIONS.clear()
-    _JOIN_TABLE_REGISTRY.clear()
-    reset_engine()
-    clear_registry()
-    yield
-
-
-def _sqlite_url(path: Path) -> str:
-    return URL.create(
-        drivername="sqlite+aiosqlite",
-        database=str(path.resolve()),
-    ).render_as_string(hide_password=False)
-
-
-@pytest.mark.asyncio
-async def test_sqlite_null_optional_datetime_hydrates_as_none_after_reconnect() -> None:
-    """Alembic-created DATETIME NULL must not become int(0) on a fresh connection."""
-
-    class Client(Model):
-        id: str = Field(default_factory=lambda: str(uuid4()), primary_key=True, db_type="text")
-        name: str
-        archived_at: datetime | None = None
-
-    with tempfile.TemporaryDirectory() as tmp:
-        db_path = Path(tmp) / "app.db"
-        uri = f"sqlite:{db_path}?mode=rwc"
-
-        engine = create_async_engine(_sqlite_url(db_path), poolclass=pool.NullPool)
-        async with engine.begin() as conn:
-            await conn.run_sync(lambda sync_conn: get_metadata().create_all(sync_conn))
-        await engine.dispose()
-
-        await ferro.connect(uri, auto_migrate=False)
-        await Client.create(name="Acme")
-        ferro.reset_engine()
-
-        await ferro.connect(uri, auto_migrate=False)
-        row = (await Client.all())[0]
-
-        with sqlite3.connect(db_path) as conn:
-            raw = conn.execute("SELECT archived_at FROM client").fetchone()[0]
-
-    assert raw is None
-    assert row.archived_at is None