ferro-orm 0.10.3__tar.gz → 0.10.4__tar.gz

{ferro_orm-0.10.3 → ferro_orm-0.10.4}/CHANGELOG.md

@@ -1,6 +1,15 @@
 # CHANGELOG
 
 
+## v0.10.4 (2026-05-24)
+
+### Bug Fixes
+
+- **query**: Cast native Postgres enum RHS in `.where()` filters
+  ([#64](https://github.com/syn54x/ferro-orm/pull/64),
+  [`7fea893`](https://github.com/syn54x/ferro-orm/commit/7fea89320fd2216a956ae32e8ae6f4829dd8fcf7))
+
+
 ## v0.10.3 (2026-05-21)
 
 ### Bug Fixes

{ferro_orm-0.10.3 → ferro_orm-0.10.4}/Cargo.lock

@@ -25,9 +25,9 @@ dependencies = [
 
 [[package]]
 name = "autocfg"
-version = "1.5.0"
+version = "1.5.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c08606f8c3cbf4ce6ec8e28fb0014a2c086708fe954eaa885384a6165172e7e8"
+checksum = "f2032f911046de80f0a198e0901378627c33f59ea0ac00e363d481118bd70a53"
 
 [[package]]
 name = "base64"
@@ -61,9 +61,9 @@ dependencies = [
 
 [[package]]
 name = "bumpalo"
-version = "3.20.2"
+version = "3.20.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5d20789868f4b01b2f2caec9f5c4e0213b41e3e5702a50157d699ae31ced2fcb"
+checksum = "72f5acc6cb2ba439de613abc23857ec3d78374d8ed5ac84e9d11336e87da8649"
 
 [[package]]
 name = "byteorder"
@@ -294,7 +294,7 @@ dependencies = [
 
 [[package]]
 name = "ferro"
-version = "0.10.3"
+version = "0.10.4"
 dependencies = [
  "dashmap",
  "once_cell",
@@ -711,9 +711,9 @@ checksum = "8f42a60cbdf9a97f5d2305f08a87dc4e09308d1276d28c869c684d7777685682"
 
 [[package]]
 name = "js-sys"
-version = "0.3.98"
+version = "0.3.99"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "67df7112613f8bfd9150013a0314e196f4800d3201ae742489d999db2f979f08"
+checksum = "142bc4740e452c1e57ade0cbc129f139c9093e354346f0872ef985f4f5cf5f11"
 dependencies = [
  "cfg-if",
  "futures-util",
@@ -1292,9 +1292,9 @@ dependencies = [
 
 [[package]]
 name = "serde_json"
-version = "1.0.149"
+version = "1.0.150"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "83fc039473c5595ace860d8c4fafa220ff474b3fc6bfdb4293327f1a37e94d86"
+checksum = "e8014e44b4736ed0538adeecded0fce2a272f22dc9578a7eb6b2d9993c74cfb9"
 dependencies = [
  "itoa",
  "memchr",
@@ -1892,9 +1892,9 @@ checksum = "b8dad83b4f25e74f184f64c43b150b91efe7647395b42289f38e50566d82855b"
 
 [[package]]
 name = "wasm-bindgen"
-version = "0.2.121"
+version = "0.2.122"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "49ace1d07c165b0864824eee619580c4689389afa9dc9ed3a4c75040d82e6790"
+checksum = "3ed04576f974d2b2fba0f38c51dbc5518011e38c36bf1143164be765528fd409"
 dependencies = [
  "cfg-if",
  "once_cell",
@@ -1905,9 +1905,9 @@ dependencies = [
 
 [[package]]
 name = "wasm-bindgen-macro"
-version = "0.2.121"
+version = "0.2.122"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8e68e6f4afd367a562002c05637acb8578ff2dea1943df76afb9e83d177c8578"
+checksum = "916151b09da36bd82f6615cbf3a419e2f0ba23a03c6160e8e92eb6bd4aa1dec6"
 dependencies = [
  "quote",
  "wasm-bindgen-macro-support",
@@ -1915,9 +1915,9 @@ dependencies = [
 
 [[package]]
 name = "wasm-bindgen-macro-support"
-version = "0.2.121"
+version = "0.2.122"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d95a9ec35c64b2a7cb35d3fead40c4238d0940c86d107136999567a4703259f2"
+checksum = "299047362ccbfce148b67ab7e73349f77748e00c8296f9542adfad2ad82c5c5e"
 dependencies = [
  "bumpalo",
  "proc-macro2",
@@ -1928,9 +1928,9 @@ dependencies = [
 
 [[package]]
 name = "wasm-bindgen-shared"
-version = "0.2.121"
+version = "0.2.122"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c4e0100b01e9f0d03189a92b96772a1fb998639d981193d7dbab487302513441"
+checksum = "9a929b2c61f11ba3e9bc35b50c1f25cb38e0e892c0c231ae2b8cf78d5dad4437"
 dependencies = [
  "unicode-ident",
 ]

{ferro_orm-0.10.3 → ferro_orm-0.10.4}/Cargo.toml

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

{ferro_orm-0.10.3 → ferro_orm-0.10.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ferro-orm
-Version: 0.10.3
+Version: 0.10.4
 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.3 → ferro_orm-0.10.4}/pyproject.toml

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

{ferro_orm-0.10.3 → ferro_orm-0.10.4}/src/lib.rs

@@ -9,6 +9,7 @@ mod connection;
 mod operations;
 mod query;
 mod schema;
+mod schema_bind;
 mod state;
 
 use crate::state::MODEL_REGISTRY;

{ferro_orm-0.10.3 → ferro_orm-0.10.4}/src/operations.rs

@@ -560,30 +560,6 @@ async fn postgres_temporal_cast_by_column(
     Ok(out)
 }
 
-fn postgres_enum_type_name_for_column(
-    col_name: &str,
-    enum_udt: &HashMap<String, String>,
-    col_info: Option<&serde_json::Value>,
-) -> Option<String> {
-    // db_type takes precedence over the JSON-schema enum_type_name: when the
-    // user has asked for `text` / `varchar(N)` / etc. storage, the column is
-    // no longer a native Postgres enum UDT and we must not CAST values to a
-    // non-existent type. This mirrors the Alembic-side _map_to_sa_type
-    // override. See AGENTS.md § I-1.
-    if let Some(info) = col_info
-        && info.get("db_type").and_then(|v| v.as_str()).is_some()
-    {
-        return None;
-    }
-
-    enum_udt.get(col_name).cloned().or_else(|| {
-        col_info?
-            .get("enum_type_name")?
-            .as_str()
-            .map(std::string::ToString::to_string)
-    })
-}
-
 fn schema_property<'a>(
     schema: &'a serde_json::Value,
     col_name: &str,
@@ -630,12 +606,10 @@ fn schema_value_expr(
 
     if let serde_json::Value::String(s) = value
         && backend == SqlDialect::Postgres
-        && let Some(tn) = postgres_enum_type_name_for_column(col_name, enum_udt, col_info)
+        && let Some(tn) =
+            crate::schema_bind::postgres_enum_type_name_for_column(col_name, enum_udt, col_info)
     {
-        return Ok(
-            Expr::value(sea_query::Value::String(Some(Box::new(s.clone()))))
-                .cast_as(Alias::new(tn.as_str())),
-        );
+        return Ok(crate::schema_bind::postgres_enum_string_rhs_expr(s, &tn));
     }
 
     if is_uuid_pg {
@@ -1572,7 +1546,7 @@ pub fn fetch_filtered<'py>(
     let name = cls.getattr("__name__")?.extract::<String>()?;
     let cls_py = cls.unbind();
 
-    let query_def: QueryDef = serde_json::from_str(&query_json).map_err(|e| {
+    let mut query_def: QueryDef = serde_json::from_str(&query_json).map_err(|e| {
         pyo3::exceptions::PyValueError::new_err(format!("Invalid query JSON: {}", e))
     })?;
 
@@ -1582,10 +1556,10 @@ pub fn fetch_filtered<'py>(
         let use_identity_map = engine.is_identity_map_enabled();
 
         let table_name = name.to_lowercase();
-        let pg_native_enum_cols: HashSet<String> = {
-            let m = postgres_enum_udt_by_column(&table_name, &engine, &tx_conn, backend).await?;
-            m.keys().cloned().collect()
-        };
+        let postgres_enum_udt =
+            postgres_enum_udt_by_column(&table_name, &engine, &tx_conn, backend).await?;
+        query_def.postgres_enum_udt = postgres_enum_udt.clone();
+        let pg_native_enum_cols: HashSet<String> = postgres_enum_udt.keys().cloned().collect();
         // ...
         let (sql, bind_values, pk_col, schema_for_decode) = {
             let registry = MODEL_REGISTRY.read().map_err(|_| {
@@ -1762,7 +1736,7 @@ pub fn count_filtered(
     tx_id: Option<String>,
     using: Option<String>,
 ) -> PyResult<Bound<'_, PyAny>> {
-    let query_def: QueryDef = serde_json::from_str(&query_json).map_err(|e| {
+    let mut query_def: QueryDef = serde_json::from_str(&query_json).map_err(|e| {
         pyo3::exceptions::PyValueError::new_err(format!("Invalid query JSON: {}", e))
     })?;
 
@@ -1770,6 +1744,8 @@ pub fn count_filtered(
         let (_, engine, tx_conn, backend) = active_route_for_operation(tx_id, using)?;
 
         let table_name = name.to_lowercase();
+        query_def.postgres_enum_udt =
+            postgres_enum_udt_by_column(&table_name, &engine, &tx_conn, backend).await?;
         // ... sql ...
         let (sql, bind_values) = {
             let mut select = Query::select();
@@ -1964,7 +1940,7 @@ pub fn delete_filtered(
     tx_id: Option<String>,
     using: Option<String>,
 ) -> PyResult<Bound<'_, PyAny>> {
-    let query_def: QueryDef = serde_json::from_str(&query_json).map_err(|e| {
+    let mut query_def: QueryDef = serde_json::from_str(&query_json).map_err(|e| {
         pyo3::exceptions::PyValueError::new_err(format!("Invalid query JSON: {}", e))
     })?;
 
@@ -1972,6 +1948,8 @@ pub fn delete_filtered(
         let (_, engine, tx_conn, backend) = active_route_for_operation(tx_id, using)?;
 
         let table_name = name.to_lowercase();
+        query_def.postgres_enum_udt =
+            postgres_enum_udt_by_column(&table_name, &engine, &tx_conn, backend).await?;
         // ... sql ...
         let (sql, bind_values) = {
             let mut delete = Query::delete();
@@ -2008,7 +1986,7 @@ pub fn update_filtered(
     tx_id: Option<String>,
     using: Option<String>,
 ) -> PyResult<Bound<'_, PyAny>> {
-    let query_def: QueryDef = serde_json::from_str(&query_json).map_err(|e| {
+    let mut query_def: QueryDef = serde_json::from_str(&query_json).map_err(|e| {
         pyo3::exceptions::PyValueError::new_err(format!("Invalid query JSON: {}", e))
     })?;
 
@@ -2025,6 +2003,7 @@ pub fn update_filtered(
 
         let table_name = name.to_lowercase();
         let enum_udt = postgres_enum_udt_by_column(&table_name, &engine, &tx_conn, backend).await?;
+        query_def.postgres_enum_udt = enum_udt.clone();
         let uuid_columns =
             postgres_uuid_column_names(&table_name, &engine, &tx_conn, backend).await?;
         let ts_cast =

{ferro_orm-0.10.3 → ferro_orm-0.10.4}/src/query.rs

@@ -2,6 +2,7 @@ use crate::state::{MODEL_REGISTRY, SqlDialect};
 use sea_query::{Alias, Condition, Expr, SimpleExpr};
 use serde::Deserialize;
 use serde_json::Value;
+use std::collections::HashMap;
 
 #[derive(Debug, Deserialize)]
 pub struct QueryNode {
@@ -38,6 +39,10 @@ pub struct QueryDef {
     pub limit: Option<u64>,
     pub offset: Option<u64>,
     pub m2m: Option<M2mContext>,
+    /// Populated from `pg_catalog` before building filter SQL. Not part of the
+    /// Python query JSON payload.
+    #[serde(skip)]
+    pub postgres_enum_udt: HashMap<String, String>,
 }
 
 impl QueryDef {
@@ -202,6 +207,12 @@ impl QueryDef {
     ) -> SimpleExpr {
         if let Value::String(s) = val {
             if backend == SqlDialect::Postgres {
+                if let Some(tn) =
+                    crate::schema_bind::native_postgres_enum_udt_name(col_name, &self.postgres_enum_udt)
+                {
+                    return crate::schema_bind::postgres_enum_string_rhs_expr(s, tn);
+                }
+
                 if let Ok(parsed) = uuid::Uuid::parse_str(s) {
                     let schema_uuid = model_column_is_uuid(&self.model_name, col_name);
                     if schema_uuid || infer_uuid_without_schema {
@@ -430,6 +441,7 @@ mod tests {
     use crate::backend::BackendKind;
     use sea_query::{Alias, PostgresQueryBuilder, Query, SqliteQueryBuilder, Value as SeaValue};
     use serde_json::json;
+    use std::collections::HashMap;
 
     fn empty_query_def(model_name: &str) -> QueryDef {
         QueryDef {
@@ -439,6 +451,7 @@ mod tests {
             limit: None,
             offset: None,
             m2m: None,
+            postgres_enum_udt: HashMap::new(),
         }
     }
 
@@ -479,6 +492,7 @@ mod tests {
             limit: None,
             offset: None,
             m2m: None,
+            postgres_enum_udt: HashMap::new(),
         };
         let mut select = Query::select();
         select
@@ -508,6 +522,7 @@ mod tests {
             limit: None,
             offset: None,
             m2m: None,
+            postgres_enum_udt: HashMap::new(),
         };
         let mut select = Query::select();
         select
@@ -675,6 +690,53 @@ mod tests {
         }
     }
 
+    #[test]
+    fn enum_rhs_emits_cast_to_schema_enum_type_on_postgres() {
+        let mut query_def = empty_query_def("WidgetColor");
+        query_def
+            .postgres_enum_udt
+            .insert("color".to_string(), "color".to_string());
+
+        let rhs = query_def.value_rhs_simple_expr_for_backend(
+            "color",
+            &json!("red"),
+            false,
+            BackendKind::Postgres,
+        );
+        let sql = Query::select().expr(rhs).to_string(PostgresQueryBuilder);
+
+        assert!(
+            sql.to_lowercase().contains("as \"color\"") || sql.to_lowercase().contains("as color"),
+            "enum filter rhs should CAST to the UDT name, got: {sql}"
+        );
+    }
+
+    #[test]
+    fn enum_rhs_skips_cast_without_native_enum_column() {
+        crate::state::MODEL_REGISTRY.write().unwrap().insert(
+            "WidgetTextColor".to_string(),
+            json!({
+                "properties": {
+                    "color": {"enum_type_name": "color", "db_type": "text"}
+                }
+            }),
+        );
+        let query_def = empty_query_def("WidgetTextColor");
+
+        let rhs = query_def.value_rhs_simple_expr_for_backend(
+            "color",
+            &json!("red"),
+            false,
+            BackendKind::Postgres,
+        );
+        let sql = Query::select().expr(rhs).to_string(PostgresQueryBuilder);
+
+        assert!(
+            !sql.to_lowercase().contains("as \"color\"") && !sql.to_lowercase().contains("as color"),
+            "auto-migrate TEXT enum columns must not cast without catalog UDT: {sql}"
+        );
+    }
+
     #[test]
     fn decimal_rhs_keeps_numeric_cast_for_now() {
         // Native numeric typed binds are deferred (plan §3 Scope Boundaries);

ferro_orm-0.10.4/src/schema_bind.rs

@@ -0,0 +1,49 @@
+//! Shared schema-driven bind helpers for INSERT/UPDATE and query-filter paths.
+
+use sea_query::{Alias, Expr, SimpleExpr};
+use std::collections::HashMap;
+
+/// Native Postgres enum UDT for `col_name`, from catalog introspection only.
+///
+/// Query-filter predicates use this path so auto-migrate TEXT columns (which
+/// carry `enum_type_name` in schema but are not `typtype = 'e'`) keep plain
+/// text binds. INSERT/UPDATE may still fall back to schema metadata via
+/// [`postgres_enum_type_name_for_column`].
+pub(crate) fn native_postgres_enum_udt_name<'a>(
+    col_name: &str,
+    enum_udt: &'a HashMap<String, String>,
+) -> Option<&'a str> {
+    enum_udt.get(col_name).map(|s| s.as_str())
+}
+
+/// Resolve the Postgres enum UDT name for a column when binding a string RHS.
+///
+/// `enum_udt` comes from catalog introspection (INSERT/UPDATE). `col_info` is
+/// the model field schema fragment (`enum_type_name`, `db_type`, etc.).
+///
+/// When `db_type` is set, native enum casting is suppressed — the column is no
+/// longer stored as a Postgres enum UDT (see AGENTS.md I-1 / Alembic parity).
+pub(crate) fn postgres_enum_type_name_for_column(
+    col_name: &str,
+    enum_udt: &HashMap<String, String>,
+    col_info: Option<&serde_json::Value>,
+) -> Option<String> {
+    if let Some(info) = col_info
+        && info.get("db_type").and_then(|v| v.as_str()).is_some()
+    {
+        return None;
+    }
+
+    enum_udt.get(col_name).cloned().or_else(|| {
+        col_info?
+            .get("enum_type_name")?
+            .as_str()
+            .map(std::string::ToString::to_string)
+    })
+}
+
+/// RHS expression for a non-null string compared against a native Postgres enum column.
+pub(crate) fn postgres_enum_string_rhs_expr(s: &str, enum_type_name: &str) -> SimpleExpr {
+    Expr::value(sea_query::Value::String(Some(Box::new(s.to_string()))))
+        .cast_as(Alias::new(enum_type_name))
+}

{ferro_orm-0.10.3 → ferro_orm-0.10.4}/tests/test_structural_types.py

@@ -276,6 +276,45 @@ async def test_native_postgres_enum_column_decodes_via_text_cast(
     assert fetched.format == TranscriptFormat.PDF
 
 
+@pytest.mark.asyncio
+@pytest.mark.postgres_only
+async def test_native_postgres_enum_where_lambda_count(db_url, postgres_base_url, db_schema_name):
+    """Regression for #63: filter predicates must cast enum RHS to the PG UDT."""
+
+    class Color(str, Enum):
+        RED = "red"
+        BLUE = "blue"
+
+    class Widget(Model):
+        id: Annotated[int | None, FerroField(primary_key=True)] = None
+        color: Color
+
+    import psycopg
+
+    with psycopg.connect(postgres_base_url) as conn:
+        conn.execute(f'SET search_path TO "{db_schema_name}"')
+        conn.execute("CREATE TYPE color AS ENUM ('red', 'blue')")
+        conn.execute(
+            """
+            CREATE TABLE widget (
+                id integer PRIMARY KEY,
+                color color NOT NULL
+            )
+            """
+        )
+        conn.execute("INSERT INTO widget (id, color) VALUES (1, 'red'), (2, 'blue')")
+        conn.commit()
+
+    await connect(db_url, auto_migrate=False)
+
+    count = await Widget.where(lambda w, c=Color.RED: w.color == c).count()
+    assert count == 1
+
+    rows = await Widget.where(lambda w: w.color != Color.BLUE).all()
+    assert len(rows) == 1
+    assert rows[0].color == Color.RED
+
+
 @pytest.mark.asyncio
 @pytest.mark.postgres_only
 async def test_native_postgres_enum_plain_str_column(