ferrum-orm 0.1.1__tar.gz → 0.1.2__tar.gz

{ferrum_orm-0.1.1 → ferrum_orm-0.1.2}/Cargo.lock

@@ -223,7 +223,7 @@ checksum = "9f1f227452a390804cdb637b74a86990f2a7d7ba4b7d5693aac9b4dd6defd8d6"
 
 [[package]]
 name = "ferrum-core"
-version = "0.1.1"
+version = "0.1.2"
 dependencies = [
  "criterion",
  "proptest",
@@ -234,7 +234,7 @@ dependencies = [
 
 [[package]]
 name = "ferrum-migrate"
-version = "0.1.1"
+version = "0.1.2"
 dependencies = [
  "ferrum-core",
  "serde",
@@ -243,7 +243,7 @@ dependencies = [
 
 [[package]]
 name = "ferrum-pyo3"
-version = "0.1.1"
+version = "0.1.2"
 dependencies = [
  "ferrum-core",
  "ferrum-sql",
@@ -254,7 +254,7 @@ dependencies = [
 
 [[package]]
 name = "ferrum-sql"
-version = "0.1.1"
+version = "0.1.2"
 dependencies = [
  "criterion",
  "ferrum-core",
@@ -380,15 +380,6 @@ dependencies = [
  "serde_core",
 ]
 
-[[package]]
-name = "indoc"
-version = "2.0.7"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "79cf5c93f93228cf8efb3ba362535fb11199ac548a09ce117c9b1adc3030d706"
-dependencies = [
- "rustversion",
-]
-
 [[package]]
 name = "is-terminal"
 version = "0.4.17"
@@ -456,15 +447,6 @@ version = "2.8.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "88904434abc2901f197fe8cc55f0445e7ded921dba5911dad2e2b39b48e663c4"
 
-[[package]]
-name = "memoffset"
-version = "0.9.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "488016bfae457b036d996092f6cb448677611ce4449e970ceaf42695203f218a"
-dependencies = [
- "autocfg",
-]
-
 [[package]]
 name = "num-traits"
 version = "0.2.19"
@@ -575,37 +557,32 @@ dependencies = [
 
 [[package]]
 name = "pyo3"
-version = "0.22.6"
+version = "0.29.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f402062616ab18202ae8319da13fa4279883a2b8a9d9f83f20dbade813ce1884"
+checksum = "cd274650b21d4bfc26a0a47587962c1edb425f69287324355cd040c3ea66071c"
 dependencies = [
- "cfg-if",
- "indoc",
  "libc",
- "memoffset",
  "once_cell",
  "portable-atomic",
  "pyo3-build-config",
  "pyo3-ffi",
  "pyo3-macros",
- "unindent",
 ]
 
 [[package]]
 name = "pyo3-build-config"
-version = "0.22.6"
+version = "0.29.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b14b5775b5ff446dd1056212d778012cbe8a0fbffd368029fd9e25b514479c38"
+checksum = "c5e2a7d2f0d013342f295c048ad19237add5154a55b1c5a254c0ec93d4109078"
 dependencies = [
- "once_cell",
  "target-lexicon",
 ]
 
 [[package]]
 name = "pyo3-ffi"
-version = "0.22.6"
+version = "0.29.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9ab5bcf04a2cdcbb50c7d6105de943f543f9ed92af55818fd17b660390fc8636"
+checksum = "ca85c467da1bbc8d866eea5deff9cf29ea5f7785054a17da36e65bda9c05845b"
 dependencies = [
  "libc",
  "pyo3-build-config",
@@ -613,9 +590,9 @@ dependencies = [
 
 [[package]]
 name = "pyo3-macros"
-version = "0.22.6"
+version = "0.29.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0fd24d897903a9e6d80b968368a34e1525aeb719d568dba8b3d4bfa5dc67d453"
+checksum = "9ac53762fd065daa3194dd09337a38bd793a188100fd1a9304c4ab312d901771"
 dependencies = [
  "proc-macro2",
  "pyo3-macros-backend",
@@ -625,13 +602,12 @@ dependencies = [
 
 [[package]]
 name = "pyo3-macros-backend"
-version = "0.22.6"
+version = "0.29.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "36c011a03ba1e50152b4b394b479826cad97e7a21eb52df179cd91ac411cbfbe"
+checksum = "4ca3a1557399783172dc5bf39cfca835157732532cba56b71d2292161e53b362"
 dependencies = [
  "heck",
  "proc-macro2",
- "pyo3-build-config",
  "quote",
  "syn",
 ]
@@ -858,9 +834,9 @@ dependencies = [
 
 [[package]]
 name = "target-lexicon"
-version = "0.12.16"
+version = "0.13.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "61c41af27dd6d1e27b1b16b489db798443478cef1f06a660c96db617ba5de3b1"
+checksum = "adb6935a6f5c20170eeceb1a3835a49e12e19d792f6dd344ccc76a985ca5a6ca"
 
 [[package]]
 name = "tempfile"
@@ -923,12 +899,6 @@ version = "0.2.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "ebc1c04c71510c7f702b52b7c350734c9ff1295c464a03335b00bb84fc54f853"
 
-[[package]]
-name = "unindent"
-version = "0.2.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7264e107f553ccae879d21fbea1d6724ac785e8c3bfc762137959b5802826ef3"
-
 [[package]]
 name = "wait-timeout"
 version = "0.2.1"

{ferrum_orm-0.1.1 → ferrum_orm-0.1.2}/Cargo.toml

@@ -3,7 +3,7 @@ members = ["crates/ferrum-core", "crates/ferrum-sql", "crates/ferrum-pyo3"]
 resolver = "2"
 
 [workspace.package]
-version = "0.1.1"
+version = "0.1.2"
 edition = "2021"
 authors = ["Ferrum Contributors"]
 license = "Apache-2.0"
@@ -12,7 +12,7 @@ rust-version = "1.85"
 
 [workspace.dependencies]
 # PyO3 — only ferrum-pyo3 depends on this; declared here to pin the version
-pyo3 = { version = "0.22", features = ["abi3-py311"] }
+pyo3 = { version = "0.29", features = ["abi3-py311"] }
 
 # Serialization
 serde = { version = "1", features = ["derive"] }

{ferrum_orm-0.1.1 → ferrum_orm-0.1.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ferrum-orm
-Version: 0.1.1
+Version: 0.1.2
 Classifier: Development Status :: 3 - Alpha
 Classifier: Framework :: AsyncIO
 Classifier: Intended Audience :: Developers
@@ -115,6 +115,10 @@ users = await (
     .limit(10)
     .all(conn)
 )
+
+async with conn.transaction() as tx:
+    user = await User.objects.create(tx, email="jane@example.com")
+    await AuditLog.objects.create(tx, user_id=user.id, action="signup")
 ```
 
 ---
@@ -207,7 +211,7 @@ This allows Ferrum to maintain a Pythonic API without sacrificing performance.
 ### v0.2
 
 - [ ] Relationships
-- [ ] Transactions
+- [x] Transactions
 - [ ] Query optimization
 - [ ] Bulk operations
 

{ferrum_orm-0.1.1 → ferrum_orm-0.1.2}/README.md

@@ -56,6 +56,10 @@ users = await (
     .limit(10)
     .all(conn)
 )
+
+async with conn.transaction() as tx:
+    user = await User.objects.create(tx, email="jane@example.com")
+    await AuditLog.objects.create(tx, user_id=user.id, action="signup")
 ```
 
 ---
@@ -148,7 +152,7 @@ This allows Ferrum to maintain a Pythonic API without sacrificing performance.
 ### v0.2
 
 - [ ] Relationships
-- [ ] Transactions
+- [x] Transactions
 - [ ] Query optimization
 - [ ] Bulk operations
 

{ferrum_orm-0.1.1 → ferrum_orm-0.1.2}/crates/ferrum-core/Cargo.toml

@@ -1,5 +1,6 @@
 [package]
 name = "ferrum-core"
+publish = false
 version.workspace = true
 edition.workspace = true
 authors.workspace = true

{ferrum_orm-0.1.1 → ferrum_orm-0.1.2}/crates/ferrum-pyo3/Cargo.toml

@@ -1,5 +1,6 @@
 [package]
 name = "ferrum-pyo3"
+publish = false
 version.workspace = true
 edition.workspace = true
 authors.workspace = true

{ferrum_orm-0.1.1 → ferrum_orm-0.1.2}/crates/ferrum-pyo3/src/lib.rs

@@ -13,16 +13,9 @@
 //! - Error payloads carry structured fields only — no trace blobs, no raw `PostgreSQL`
 //!   DETAIL/HINT, no memory addresses, no local paths.
 
-// PyO3 0.22.x uses an internal `cfg(gil-refs)` feature gate that Rust's
-// `unexpected_cfgs` lint flags. This is a known upstream issue resolved in
-// PyO3 0.23+. Suppress here until the pyo3 dependency is upgraded.
-#![allow(unexpected_cfgs)]
-// PyO3 0.22's `#[pyfunction]` macro expands code that triggers `useless_conversion`
-// (false positive: macro-generated `PyErr → PyErr` coercions). Remove on pyo3 >= 0.23.
-#![allow(clippy::useless_conversion)]
-
 use pyo3::exceptions::{PyNotImplementedError, PyRuntimeError};
 use pyo3::prelude::*;
+use pyo3::IntoPyObjectExt;
 
 // With abi3, PyO3 does not support subclassing native types via `extends`.
 // Use `create_exception!` to define custom exception classes that inherit from
@@ -100,8 +93,8 @@ fn compile_query(
 
     match result {
         Ok(Ok((compiled, operation_name))) => {
-            let dict = pyo3::types::PyDict::new_bound(py);
-            dict.set_item("sql_text", &compiled.sql_text)?;
+            let dict = pyo3::types::PyDict::new(py);
+            dict.set_item("sql_text", compiled.sql_text.as_str())?;
             // `bound_params` are JSON-encoded so Python can deserialize them into
             // native types for the asyncpg driver. Never log these in Tier A hooks.
             let params: Vec<String> = compiled
@@ -111,10 +104,10 @@ fn compile_query(
                 .collect();
             dict.set_item("bound_params", params)?;
             dict.set_item("param_type_summary", compiled.param_type_summary)?;
-            dict.set_item("fingerprint", &compiled.fingerprint)?;
+            dict.set_item("fingerprint", compiled.fingerprint.as_str())?;
             // Python routes on this: "select"/"insert"/"update"/"delete".
             dict.set_item("operation", operation_name)?;
-            Ok(dict.into())
+            Ok(dict.into_any().unbind())
         }
         Ok(Err(compile_err)) => {
             // Structured compile error → catchable Python exception.
@@ -134,20 +127,20 @@ fn compile_query(
 ///
 /// Mapping: `null` → `None`, `bool` → `bool`, `number` → `int` or `float`,
 /// `string` → `str`, `array` → `list`, `object` → `dict`.
-fn json_value_to_pyobj(py: Python<'_>, val: &serde_json::Value) -> PyResult<PyObject> {
+fn json_value_to_pyobj(py: Python<'_>, val: &serde_json::Value) -> PyResult<Py<PyAny>> {
     match val {
         serde_json::Value::Null => Ok(py.None()),
-        serde_json::Value::Bool(b) => Ok(b.into_py(py)),
+        serde_json::Value::Bool(b) => (*b).into_py_any(py),
         serde_json::Value::Number(n) => {
             if let Some(i) = n.as_i64() {
-                Ok(i.into_py(py))
+                i.into_py_any(py)
             } else if let Some(f) = n.as_f64() {
-                Ok(f.into_py(py))
+                f.into_py_any(py)
             } else {
                 // u64 values > i64::MAX are represented as u64 in serde_json.
                 // Try widening to u64 before giving up.
                 if let Some(u) = n.as_u64() {
-                    Ok(u.into_py(py))
+                    u.into_py_any(py)
                 } else {
                     Err(FerrumHydrationError::new_err(
                         "numeric value is out of representable range",
@@ -155,20 +148,20 @@ fn json_value_to_pyobj(py: Python<'_>, val: &serde_json::Value) -> PyResult<PyOb
                 }
             }
         }
-        serde_json::Value::String(s) => Ok(s.as_str().into_py(py)),
+        serde_json::Value::String(s) => s.as_str().into_py_any(py),
         serde_json::Value::Array(arr) => {
-            let list = pyo3::types::PyList::empty_bound(py);
+            let list = pyo3::types::PyList::empty(py);
             for item in arr {
                 list.append(json_value_to_pyobj(py, item)?)?;
             }
-            Ok(list.into())
+            Ok(list.into_any().unbind())
         }
         serde_json::Value::Object(obj) => {
-            let dict = pyo3::types::PyDict::new_bound(py);
+            let dict = pyo3::types::PyDict::new(py);
             for (k, v) in obj {
                 dict.set_item(k, json_value_to_pyobj(py, v)?)?;
             }
-            Ok(dict.into())
+            Ok(dict.into_any().unbind())
         }
     }
 }
@@ -184,7 +177,7 @@ fn json_value_to_pyobj(py: Python<'_>, val: &serde_json::Value) -> PyResult<PyOb
 ///   column is missing/null in a row.
 /// - `FerrumInternalError` — Rust panic (should never occur in normal use; ERR-2).
 #[pyfunction]
-fn hydrate_rows(py: Python<'_>, metadata_json: &str, rows_json: &str) -> PyResult<PyObject> {
+fn hydrate_rows(py: Python<'_>, metadata_json: &str, rows_json: &str) -> PyResult<Py<PyAny>> {
     // `AssertUnwindSafe` is sound: only `&str` (Copy, RefUnwindSafe) crosses the
     // panic boundary, called exactly once.
     let unwind_result = std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| {
@@ -198,15 +191,15 @@ fn hydrate_rows(py: Python<'_>, metadata_json: &str, rows_json: &str) -> PyResul
 
     match unwind_result {
         Ok(Ok(rows)) => {
-            let list = pyo3::types::PyList::empty_bound(py);
+            let list = pyo3::types::PyList::empty(py);
             for row in &rows {
-                let dict = pyo3::types::PyDict::new_bound(py);
+                let dict = pyo3::types::PyDict::new(py);
                 for (k, v) in row {
                     dict.set_item(k, json_value_to_pyobj(py, v)?)?;
                 }
                 list.append(dict)?;
             }
-            Ok(list.into())
+            Ok(list.into_any().unbind())
         }
         Ok(Err(msg)) => Err(FerrumHydrationError::new_err(msg)),
         Err(_panic_payload) => Err(FerrumInternalError::new_err(
@@ -236,17 +229,11 @@ fn _native(py: Python<'_>, m: &Bound<'_, PyModule>) -> PyResult<()> {
     m.add_function(wrap_pyfunction!(compile_query, m)?)?;
     m.add_function(wrap_pyfunction!(hydrate_rows, m)?)?;
     m.add_function(wrap_pyfunction!(plan_migration, m)?)?;
-    m.add(
-        "FerrumInternalError",
-        py.get_type_bound::<FerrumInternalError>(),
-    )?;
-    m.add(
-        "FerrumCompileError",
-        py.get_type_bound::<FerrumCompileError>(),
-    )?;
+    m.add("FerrumInternalError", py.get_type::<FerrumInternalError>())?;
+    m.add("FerrumCompileError", py.get_type::<FerrumCompileError>())?;
     m.add(
         "FerrumHydrationError",
-        py.get_type_bound::<FerrumHydrationError>(),
+        py.get_type::<FerrumHydrationError>(),
     )?;
     Ok(())
 }

{ferrum_orm-0.1.1 → ferrum_orm-0.1.2}/crates/ferrum-sql/Cargo.toml

@@ -1,5 +1,6 @@
 [package]
 name = "ferrum-sql"
+publish = false
 version.workspace = true
 edition.workspace = true
 authors.workspace = true

{ferrum_orm-0.1.1 → ferrum_orm-0.1.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "maturin"
 
 [project]
 name = "ferrum-orm"
-version = "0.1.1"
+version = "0.1.2"
 description = "Next-generation async ORM for Python with a Rust-powered core"
 license = { text = "Apache-2.0" }
 readme = "README.md"

{ferrum_orm-0.1.1 → ferrum_orm-0.1.2}/python/ferrum/__init__.py

@@ -6,7 +6,7 @@ Import paths are stable API; internal module paths are not.
 
 from __future__ import annotations
 
-__version__ = "0.1.1"
+__version__ = "0.1.2"
 __all__ = [
     "FerrumCompileError",
     "FerrumConfigError",
@@ -28,13 +28,16 @@ __all__ = [
     "OneToOne",
     "QuerySet",
     "TSVector",
+    "Transaction",
     "Vector",
     "clear_hooks",
     "connect",
+    "contrib",
     "register_hook",
 ]
 
-from ferrum.connection import connect
+from ferrum import contrib
+from ferrum.connection import Transaction, connect
 from ferrum.errors import (
     FerrumCompileError,
     FerrumConfigError,

{ferrum_orm-0.1.1 → ferrum_orm-0.1.2}/python/ferrum/cli/inspectdb_cmd.py

@@ -8,7 +8,8 @@ Security invariants:
 - No credentials, bound values, or row data appear in emitted code or output.
 - All queries use parameterised ``$1`` placeholders — schema name is the only
   variable and is never interpolated into an identifier position.
-- ``ferrum_migrations`` and system tables (``pg_*``) are excluded by the query.
+- ``ferrum_migrations``, ``pg_*`` extension objects, and non-table relations
+  are excluded by the query (``BASE TABLE`` only).
 """
 
 from __future__ import annotations
@@ -42,9 +43,35 @@ _HEADER = textwrap.dedent("""\
 """)
 
 
+# Tables never scaffolded as Ferrum models.
+_EXCLUDED_TABLES: frozenset[str] = frozenset({"ferrum_migrations"})
+
+# Extension / catalog objects that may appear in ``public`` as views.
+_EXCLUDED_TABLE_PREFIXES: tuple[str, ...] = ("pg_",)
+
+
+def _is_scaffoldable_table(table_name: str) -> bool:
+    """Return True when *table_name* should become a scaffolded model."""
+    if table_name in _EXCLUDED_TABLES:
+        return False
+    return not table_name.startswith(_EXCLUDED_TABLE_PREFIXES)
+
+
+def _singularize_table_name(table_name: str) -> str:
+    """Best-effort singular form of a plural snake_case table name."""
+    if table_name.endswith("ies") and len(table_name) > 3:
+        return f"{table_name[:-3]}y"
+    if table_name.endswith(("ches", "shes", "xes", "ses", "zes")) and len(table_name) > 3:
+        return table_name[:-2]
+    if len(table_name) > 1 and table_name.endswith("s") and not table_name.endswith("ss"):
+        return table_name[:-1]
+    return table_name
+
+
 def _to_class_name(table_name: str) -> str:
-    """Convert snake_case table name to PascalCase class name."""
-    return "".join(part.capitalize() for part in table_name.split("_"))
+    """Convert a table name to a singular PascalCase model class name."""
+    singular = _singularize_table_name(table_name)
+    return "".join(part.capitalize() for part in singular.split("_"))
 
 
 def _pg_type_to_ferrum(
@@ -129,12 +156,15 @@ def _pg_type_to_ferrum(
 # ---------------------------------------------------------------------------
 
 _COL_QUERY = """\
-SELECT table_name, column_name, data_type, character_maximum_length,
-       numeric_precision, numeric_scale, is_nullable, column_default,
-       ordinal_position
-FROM information_schema.columns
-WHERE table_schema = $1 AND table_name != 'ferrum_migrations'
-ORDER BY table_name, ordinal_position
+SELECT c.table_name, c.column_name, c.data_type, c.character_maximum_length,
+       c.numeric_precision, c.numeric_scale, c.is_nullable, c.column_default,
+       c.ordinal_position
+FROM information_schema.columns c
+JOIN information_schema.tables t
+    ON t.table_schema = c.table_schema AND t.table_name = c.table_name
+WHERE c.table_schema = $1
+  AND t.table_type = 'BASE TABLE'
+ORDER BY c.table_name, c.ordinal_position
 """
 
 _FK_QUERY = """\
@@ -148,7 +178,10 @@ JOIN information_schema.referential_constraints rc
     ON kcu.constraint_name = rc.constraint_name
 JOIN information_schema.constraint_column_usage ccu
     ON rc.unique_constraint_name = ccu.constraint_name
+JOIN information_schema.tables t
+    ON t.table_schema = kcu.table_schema AND t.table_name = kcu.table_name
 WHERE kcu.table_schema = $1
+  AND t.table_type = 'BASE TABLE'
 """
 
 _PK_QUERY = """\
@@ -156,7 +189,11 @@ SELECT kcu.table_name, kcu.column_name
 FROM information_schema.key_column_usage kcu
 JOIN information_schema.table_constraints tc
     ON kcu.constraint_name = tc.constraint_name
-WHERE tc.constraint_type = 'PRIMARY KEY' AND kcu.table_schema = $1
+JOIN information_schema.tables t
+    ON t.table_schema = kcu.table_schema AND t.table_name = kcu.table_name
+WHERE tc.constraint_type = 'PRIMARY KEY'
+  AND kcu.table_schema = $1
+  AND t.table_type = 'BASE TABLE'
 """
 
 
@@ -181,7 +218,11 @@ def _render_class(
             foreign_column_name, delete_rule).
     """
     class_name = _to_class_name(table_name)
-    lines: list[str] = [f"class {class_name}(Model):"]
+    lines: list[str] = [
+        f"class {class_name}(Model):",
+        f"    model_config = ferrum.ModelConfig(table={table_name!r})",
+        "",
+    ]
 
     for col in columns:
         col_name: str = col["column_name"]
@@ -270,21 +311,27 @@ async def run_inspectdb(
     # pk_cols_by_table: table_name → set of pk column names
     pk_cols_by_table: dict[str, set[str]] = defaultdict(set)
     for row in pk_rows:
-        pk_cols_by_table[row["table_name"]].add(row["column_name"])
+        table = row["table_name"]
+        if _is_scaffoldable_table(table):
+            pk_cols_by_table[table].add(row["column_name"])
 
     # fk_by_table: table_name → {column_name: fk info dict}
     fk_by_table: dict[str, dict[str, dict]] = defaultdict(dict)
     for row in fk_rows:
-        fk_by_table[row["table_name"]][row["column_name"]] = {
-            "foreign_table_name": row["foreign_table_name"],
-            "foreign_column_name": row["foreign_column_name"],
-            "delete_rule": row["delete_rule"],
-        }
+        table = row["table_name"]
+        if _is_scaffoldable_table(table):
+            fk_by_table[table][row["column_name"]] = {
+                "foreign_table_name": row["foreign_table_name"],
+                "foreign_column_name": row["foreign_column_name"],
+                "delete_rule": row["delete_rule"],
+            }
 
     # cols_by_table: table_name → ordered list of column dicts
     cols_by_table: dict[str, list[dict]] = defaultdict(list)
     for row in col_rows:
-        cols_by_table[row["table_name"]].append(dict(row))
+        table = row["table_name"]
+        if _is_scaffoldable_table(table):
+            cols_by_table[table].append(dict(row))
 
     tables = list(cols_by_table.keys())
 

{ferrum_orm-0.1.1 → ferrum_orm-0.1.2}/python/ferrum/cli/migrate_cmd.py

@@ -20,7 +20,7 @@ import typer
 from rich import print as rprint
 
 from ferrum.connection import connect
-from ferrum.errors import FerrumConfigError, FerrumMigrationError
+from ferrum.errors import FerrumConfigError, FerrumMigrationError, migration_op_failure
 from ferrum.migrations import ledger as _ledger
 from ferrum.migrations import loader as _loader
 from ferrum.migrations.orchestrator import _op_to_sql
@@ -95,41 +95,56 @@ async def run_migrate(
                     rprint(f"  [dim][dry-run][/dim] would apply {len(ops)} operations")
                     continue
 
-                try:
-                    driver = conn._require_driver()
-                    dialect = conn.dialect
-                    if dialect == "postgres":
-                        pool = getattr(driver, "_pool", None)
-                        if pool is None:
-                            raise FerrumMigrationError("PostgreSQL pool is not open. [FERR-M001]")
-                        async with pool.acquire() as db_conn, db_conn.transaction():
-                            for op in ops:
-                                sql = _op_to_sql(op.to_op_dict(), dialect=dialect)
+                driver = conn._require_driver()
+                dialect = conn.dialect
+                if dialect == "postgres":
+                    pool = getattr(driver, "_pool", None)
+                    if pool is None:
+                        raise FerrumMigrationError("PostgreSQL pool is not open. [FERR-M001]")
+                    async with pool.acquire() as db_conn, db_conn.transaction():
+                        for op_index, op in enumerate(ops):
+                            op_dict = op.to_op_dict()
+                            sql = _op_to_sql(op_dict, dialect=dialect)
+                            try:
                                 await db_conn.execute(sql)
-                            await _ledger.record_applied(
-                                conn,
-                                digest,
-                                environment=env,
-                                description=module.name,
-                            )
-                    else:
-                        for op in ops:
-                            sql = _op_to_sql(op.to_op_dict(), dialect=dialect)
-                            await driver.execute(sql)
+                            except FerrumMigrationError:
+                                raise
+                            except Exception as exc:
+                                raise migration_op_failure(
+                                    action="apply",
+                                    migration_name=module.name,
+                                    op_index=op_index,
+                                    op=op_dict,
+                                    exc=exc,
+                                ) from None
                         await _ledger.record_applied(
                             conn,
                             digest,
                             environment=env,
                             description=module.name,
                         )
-                except FerrumMigrationError:
-                    raise
-                except Exception as exc:
-                    raise FerrumMigrationError(
-                        f"Failed to apply migration {module.name!r}: "
-                        f"{type(exc).__name__} [FERR-M001]"
-                    ) from None
-
+                else:
+                    for op_index, op in enumerate(ops):
+                        op_dict = op.to_op_dict()
+                        sql = _op_to_sql(op_dict, dialect=dialect)
+                        try:
+                            await driver.execute(sql)
+                        except FerrumMigrationError:
+                            raise
+                        except Exception as exc:
+                            raise migration_op_failure(
+                                action="apply",
+                                migration_name=module.name,
+                                op_index=op_index,
+                                op=op_dict,
+                                exc=exc,
+                            ) from None
+                    await _ledger.record_applied(
+                        conn,
+                        digest,
+                        environment=env,
+                        description=module.name,
+                    )
                 rprint("  [green]OK[/green]")
 
             return 0