ferro-orm 0.6.0__tar.gz → 0.7.0__tar.gz

{ferro_orm-0.6.0 → ferro_orm-0.7.0}/CHANGELOG.md

@@ -1,6 +1,23 @@
 # CHANGELOG
 
 
+## v0.7.0 (2026-05-08)
+
+### Features
+
+- Per-connection identity_map on connect ([#47](https://github.com/syn54x/ferro-orm/pull/47),
+  [`0a1d629`](https://github.com/syn54x/ferro-orm/commit/0a1d62926538cde14fdd4f4deece21a59a1ede69))
+
+
+## v0.6.1 (2026-05-07)
+
+### Refactoring
+
+- Make ModelConnection generic to preserve model typing through .using()
+  ([#46](https://github.com/syn54x/ferro-orm/pull/46),
+  [`50d6b68`](https://github.com/syn54x/ferro-orm/commit/50d6b683059ce1d2b00942efd7267836db00eefd))
+
+
 ## v0.6.0 (2026-04-30)
 
 ### Features

{ferro_orm-0.6.0 → ferro_orm-0.7.0}/Cargo.lock

@@ -79,9 +79,9 @@ checksum = "1e748733b7cbc798e1434b6ac524f0c1ff2ab456fe201501e6497c8417a4fc33"
 
 [[package]]
 name = "cc"
-version = "1.2.61"
+version = "1.2.62"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d16d90359e986641506914ba71350897565610e87ce0ad9e6f28569db3dd5c6d"
+checksum = "a1dce859f0832a7d088c4f1119888ab94ef4b5d6795d1ce05afb7fe159d79f98"
 dependencies = [
  "find-msvc-tools",
  "shlex",
@@ -294,7 +294,7 @@ dependencies = [
 
 [[package]]
 name = "ferro"
-version = "0.6.0"
+version = "0.7.0"
 dependencies = [
  "dashmap",
  "once_cell",
@@ -711,9 +711,9 @@ checksum = "8f42a60cbdf9a97f5d2305f08a87dc4e09308d1276d28c869c684d7777685682"
 
 [[package]]
 name = "js-sys"
-version = "0.3.97"
+version = "0.3.98"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a1840c94c045fbcf8ba2812c95db44499f7c64910a912551aaaa541decebcacf"
+checksum = "67df7112613f8bfd9150013a0314e196f4800d3201ae742489d999db2f979f08"
 dependencies = [
  "cfg-if",
  "futures-util",
@@ -757,7 +757,7 @@ dependencies = [
  "bitflags",
  "libc",
  "plain",
- "redox_syscall 0.7.4",
+ "redox_syscall 0.7.5",
 ]
 
 [[package]]
@@ -1136,9 +1136,9 @@ dependencies = [
 
 [[package]]
 name = "redox_syscall"
-version = "0.7.4"
+version = "0.7.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f450ad9c3b1da563fb6948a8e0fb0fb9269711c9c73d9ea1de5058c79c8d643a"
+checksum = "4666a1a60d8412eab19d94f6d13dcc9cea0a5ef4fdf6a5db306537413c661b1b"
 dependencies = [
  "bitflags",
 ]
@@ -1699,9 +1699,9 @@ checksum = "1f3ccbac311fea05f86f61904b462b55fb3df8837a366dfc601a0161d0532f20"
 
 [[package]]
 name = "tokio"
-version = "1.52.1"
+version = "1.52.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b67dee974fe86fd92cc45b7a95fdd2f99a36a6d7b0d431a231178d3d670bbcc6"
+checksum = "8fc7f01b389ac15039e4dc9531aa973a135d7a4135281b12d7c1bc79fd57fffe"
 dependencies = [
  "bytes",
  "libc",
@@ -1892,9 +1892,9 @@ checksum = "b8dad83b4f25e74f184f64c43b150b91efe7647395b42289f38e50566d82855b"
 
 [[package]]
 name = "wasm-bindgen"
-version = "0.2.120"
+version = "0.2.121"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "df52b6d9b87e0c74c9edfa1eb2d9bf85e5d63515474513aa50fa181b3c4f5db1"
+checksum = "49ace1d07c165b0864824eee619580c4689389afa9dc9ed3a4c75040d82e6790"
 dependencies = [
  "cfg-if",
  "once_cell",
@@ -1905,9 +1905,9 @@ dependencies = [
 
 [[package]]
 name = "wasm-bindgen-macro"
-version = "0.2.120"
+version = "0.2.121"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "78b1041f495fb322e64aca85f5756b2172e35cd459376e67f2a6c9dffcedb103"
+checksum = "8e68e6f4afd367a562002c05637acb8578ff2dea1943df76afb9e83d177c8578"
 dependencies = [
  "quote",
  "wasm-bindgen-macro-support",
@@ -1915,9 +1915,9 @@ dependencies = [
 
 [[package]]
 name = "wasm-bindgen-macro-support"
-version = "0.2.120"
+version = "0.2.121"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9dcd0ff20416988a18ac686d4d4d0f6aae9ebf08a389ff5d29012b05af2a1b41"
+checksum = "d95a9ec35c64b2a7cb35d3fead40c4238d0940c86d107136999567a4703259f2"
 dependencies = [
  "bumpalo",
  "proc-macro2",
@@ -1928,9 +1928,9 @@ dependencies = [
 
 [[package]]
 name = "wasm-bindgen-shared"
-version = "0.2.120"
+version = "0.2.121"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "49757b3c82ebf16c57d69365a142940b384176c24df52a087fb748e2085359ea"
+checksum = "c4e0100b01e9f0d03189a92b96772a1fb998639d981193d7dbab487302513441"
 dependencies = [
  "unicode-ident",
 ]

{ferro_orm-0.6.0 → ferro_orm-0.7.0}/Cargo.toml

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

{ferro_orm-0.6.0 → ferro_orm-0.7.0}/PKG-INFO

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

ferro_orm-0.7.0/docs/plans/2026-05-07-001-refactor-generic-model-connection-plan.md

@@ -0,0 +1,192 @@
+---
+title: "refactor: Make ModelConnection generic to preserve model typing through .using()"
+type: refactor
+status: active
+date: 2026-05-07
+---
+
+# refactor: Make ModelConnection generic to preserve model typing through .using()
+
+## Summary
+
+`ModelConnection` (the object returned by `Model.using(name)`) is not generic, so every method that should return the bound model class falls back to the unbound `Model` base — `Transcript.using(SERVICE).get("...")` resolves to `Model | None` instead of `Transcript | None`. This plan parameterizes `ModelConnection` over `M: Model` using PEP 695 syntax, propagates `M` through every method return type, and renames the conflicting `self.using` instance attribute so the class isn't shadowing its own classmethod entrypoint. No behavior changes — pure typing + naming hygiene.
+
+---
+
+## Requirements
+
+- R1. `Transcript.using(SERVICE).get(pk)` resolves to `Transcript | None` under Pyright/Pylance.
+- R2. Every other `ModelConnection` method preserves the model type: `create -> M`, `all -> list[M]`, `select -> Query[M]`, `where -> Query[M]`, `bulk_create -> int`, `get_or_create -> tuple[M, bool]`, `update_or_create -> tuple[M, bool]`.
+- R3. The instance attribute previously named `self.using` no longer shadows the `Model.using` classmethod name.
+- R4. Existing runtime behavior is preserved — every test under `tests/test_connection.py` and `tests/test_named_connections_integration.py` continues to pass without modification.
+- R5. Public surface is unchanged: `Model.using("name")` still returns a `ModelConnection`-shaped object with all the same methods and call signatures.
+
+---
+
+## Scope Boundaries
+
+- No widening of `Model.using()` to accept transaction handles, connection objects, role hints, or anything other than the existing `name: str`.
+- No audit of unrelated typing erasure elsewhere in the ORM (relation descriptors, raw queries, query builder internals). Anything discovered during this work that is out-of-scope routes to deferred follow-up rather than expanding this plan.
+- No changes to `Query`, `Model`, or any FFI signatures — `Query` is already generic and that infrastructure is sufficient.
+- No new type-checker wiring into CI. The repo currently has no Pyright/mypy hook (see `.pre-commit-config.yaml` lines 45–51, type checking is commented out). Adding CI enforcement for static typing is a separate, larger discussion.
+
+### Deferred to Follow-Up Work
+
+- Wiring Pyright into pre-commit / CI so `assert_type` regressions fail builds: separate plan, larger scope (config, ignore lists, baseline noise).
+- Audit of `relations/descriptors.py` and other Model-returning APIs for similar erasure: separate plan if/when surfaced.
+
+---
+
+## Context & Research
+
+### Relevant Code and Patterns
+
+- `src/ferro/models.py` lines 452–455: `Model.using` classmethod, already annotated `-> ModelConnection[Self]` (the annotation is aspirational today — `ModelConnection` is not actually subscriptable).
+- `src/ferro/models.py` lines 557–619: `ModelConnection` class definition. All eight methods to retype live here.
+- `src/ferro/query/builder.py` line 29: `class Query(Generic[T])` — already generic. `select()` and `where()` should return `Query[M]` after this refactor; the constructor `Query(self.model_cls, using=...)` already infers `T` from the class argument.
+- `src/ferro/relations/descriptors.py` line 112: `await self._target_model.using(origin).get(id_val)` — only external caller of `ModelConnection`'s instance-level methods we found in repo. Will benefit automatically from the typing fix; no change needed.
+
+### Internal Usages of `self.using` (the instance attribute being renamed)
+
+Confirmed via grep — all references are inside `ModelConnection`'s own method bodies:
+
+- `models.py:566` — `await instance.save(using=self.using)`
+- `models.py:570` — `using=self.using`
+- `models.py:573` — `Query(..., using=self.using)`
+- `models.py:588` — `bulk_create(..., using=self.using)`
+- `models.py:593` — `Query(..., using=self.using)`
+- `models.py:607` — `Query(..., using=self.using)`
+- `models.py:615` — `await instance.save(using=self.using)`
+
+No external code reads `instance.using` on a `ModelConnection` object. Renaming is safe.
+
+### Institutional Learnings
+
+- `.cursorrules` §4 — TDD workflow: write a failing test first, then implement. Applies here even though the "test" for the typing fix is a static `assert_type` rather than runtime assertion. The runtime regression test for the rename is conventional pytest.
+- `AGENTS.md` I-3 — no `unwrap()` across FFI. Not applicable here (Python-only change), but reinforces "this should not need to touch Rust."
+- `AGENTS.md` I-5 — `docs/solutions/` is institutional memory. Worth adding a short note under `docs/solutions/patterns/` if the PEP 695 generic syntax is the first instance in the codebase, so future agents have a reference.
+
+### External References
+
+- PEP 695 (Type Parameter Syntax, Python 3.12+) — Ferro's `requires-python = ">=3.13"` makes this the modern default over `Generic[M]`. No external lookup needed; the syntax is well-known.
+
+---
+
+## Key Technical Decisions
+
+- **Use PEP 695 syntax (`class ModelConnection[M: Model]:`) over `Generic[M]`.** Project pins Python 3.13+ (`pyproject.toml:9`), so the older syntax has no compatibility benefit and adds an import (`Generic`, `TypeVar`). PEP 695 is also what `Query` should eventually move to for consistency, but that migration is out of scope here.
+- **Rename `self.using` to `self._connection_name`.** Underscore-prefix signals "internal — don't read this from outside the class," which matches how the attribute is actually used. Avoids the `Model.using` / `ModelConnection.using` name collision that prompted this work in the first place.
+- **Test typing via `typing.assert_type` co-located with existing connection tests, not in a new `tests/typing/` directory.** No type checker runs in CI today, so a separate typing test directory would be a discoverability problem (no signal points at it). Inline `assert_type` calls in the existing test files make the intent visible to readers, run as no-ops at runtime, and can be picked up later if/when Pyright is wired into CI.
+
+---
+
+## Open Questions
+
+### Resolved During Planning
+
+- *Should we use `Generic[M]` or PEP 695 `[M: Model]`?* — PEP 695, see Key Technical Decisions.
+- *What to rename `self.using` to?* — `self._connection_name`, see Key Technical Decisions.
+- *Do we need to update `src/ferro/_core.pyi`?* — No. `ModelConnection` is a pure-Python class; no FFI signatures cross.
+
+### Deferred to Implementation
+
+- *Does `Query`'s existing generic propagation flow through the new `M` cleanly when `ModelConnection.select()` returns `Query[M]`?* — Should "just work" since `Query(model_cls, ...)` infers `T` from `type[T]`, and after the refactor `self.model_cls: type[M]`. Verified at implementation time by writing the `assert_type` calls and running Pyright locally.
+
+---
+
+## Implementation Units
+
+- U1. **Add typing regression coverage for `.using()`**
+
+**Goal:** Lock in the desired post-refactor types via `typing.assert_type` calls so the typing improvement is observable and won't silently regress.
+
+**Requirements:** R1, R2
+
+**Dependencies:** None.
+
+**Files:**
+- Modify: `tests/test_connection.py` (or `tests/test_named_connections_integration.py` — pick the file that already exercises the same model)
+- Test: same file (typing assertions co-located with runtime tests)
+
+**Approach:**
+- Add a small block of `typing.assert_type(...)` calls against an existing test model (e.g., `ConnectionRouteMarker` or `NamedSmokeMarker`).
+- Cover the full surface called out in R2: `create`, `all`, `select`, `where`, `bulk_create`, `get_or_create`, `update_or_create`, `get`.
+- These are no-ops at runtime; Pyright/Pylance will flag any future regression. Document at the top of the block that they're for static type checking.
+
+**Execution note:** Test-first per `.cursorrules` §4. Write these assertions before touching `models.py` — Pyright should report errors on every line until U2 lands.
+
+**Patterns to follow:**
+- Existing test file structure under `tests/`.
+
+**Test scenarios:**
+- Happy path: `assert_type(ConnectionRouteMarker.using("service"), ModelConnection[ConnectionRouteMarker])` — proves the classmethod's annotation is now truthful.
+- Happy path: `assert_type(await ConnectionRouteMarker.using("service").get(1), ConnectionRouteMarker | None)` — covers R1 directly.
+- Happy path: one `assert_type` per remaining method in R2 (`create`, `all`, `select`, `where`, `bulk_create`, `get_or_create`, `update_or_create`).
+- Test expectation at runtime: these statements should execute without error. `assert_type` is a runtime no-op.
+
+**Verification:**
+- Before U2 lands: `uv run pytest` passes (assert_type doesn't fail at runtime), but Pyright on the test file reports type errors on each new line.
+- After U2 lands: Pyright on the test file is clean.
+
+---
+
+- U2. **Make `ModelConnection` generic and rename the connection-name attribute**
+
+**Goal:** Parameterize `ModelConnection` over `M: Model` and rename `self.using` → `self._connection_name`.
+
+**Requirements:** R1, R2, R3, R5
+
+**Dependencies:** U1.
+
+**Files:**
+- Modify: `src/ferro/models.py` (lines 557–619 — the `ModelConnection` class body)
+
+**Approach:**
+- Change class header to `class ModelConnection[M: Model]:`.
+- `__init__` signature: `model_cls: type[M], connection_name: str` (parameter name change is internal — callers go through `Model.using()` which positional-passes the string).
+- `self.model_cls: type[M] = model_cls`; `self._connection_name: str = connection_name`.
+- Replace all seven `self.using` references in method bodies with `self._connection_name`.
+- Method return-type annotations:
+  - `create(...) -> M`
+  - `all() -> list[M]`
+  - `select() -> Query[M]`
+  - `where(node) -> Query[M]`
+  - `get(pk) -> M | None`
+  - `bulk_create(instances: list[M]) -> int`
+  - `get_or_create(...) -> tuple[M, bool]`
+  - `update_or_create(...) -> tuple[M, bool]`
+- `Model.using` classmethod (lines 452–455) stays as-is — its `-> "ModelConnection[Self]"` annotation now resolves correctly.
+
+**Patterns to follow:**
+- `src/ferro/query/builder.py:29` (`class Query(Generic[T])`) for how a generic ORM-side class is wired, though we use the newer PEP 695 syntax here.
+
+**Test scenarios:**
+- Covers R4. Happy path: full existing `tests/test_connection.py` and `tests/test_named_connections_integration.py` suites pass unchanged. The rename is purely internal so no behavior changes.
+- Covers R1, R2. Happy path: every `assert_type` call added in U1 type-checks clean under Pyright after this unit lands.
+- Edge case: confirm that `Model.using("name").select().where(...).first()` chains all the way through — each link preserves `M`. Already covered indirectly by the U1 `select` and `where` assertions plus existing query tests.
+
+**Verification:**
+- `uv run pytest tests/test_connection.py tests/test_named_connections_integration.py` is green.
+- `uv run maturin develop && uv run pytest` is green (full suite — confirms no relation-descriptor or other internal caller broke).
+- Manually run Pyright on `tests/test_connection.py` (or whichever file got the U1 assertions): no errors on the typing block.
+- Visual check: `Transcript.using(SERVICE).get("…")` in a fresh editor session shows `Transcript | None` in the hover tooltip.
+
+---
+
+## Risks & Dependencies
+
+| Risk | Mitigation |
+|------|------------|
+| Renaming `self.using` accidentally breaks an external caller we missed in the grep. | Pre-flight grep confirmed all references are internal to the class body. The full pytest suite runs in U2 verification. |
+| `Query[M]` doesn't propagate as cleanly as expected because `Query`'s `__init__` infers `T` differently than expected from `type[M]`. | Verified at implementation time via the `assert_type(self.select(), Query[M])` assertion in U1. If it fails, fall back to an explicit cast or constructor annotation; document the fix in `docs/solutions/patterns/`. |
+| The typing improvement degrades inside generic mixins or subclasses of `Model` due to `Self` interaction. | `Model.using` returns `ModelConnection[Self]`; this is the standard pattern and shouldn't fight `M: Model`. If a subclass-specific issue surfaces, scope the fix to that subclass — don't expand U2. |
+
+---
+
+## Sources & References
+
+- Brainstorm conversation in this session establishing scope (generic + rename, no broader audit).
+- `src/ferro/models.py:452-619` — current `Model.using` and `ModelConnection` definitions.
+- `src/ferro/query/builder.py:29` — existing generic ORM class as reference pattern.
+- `pyproject.toml:9` — `requires-python = ">=3.13"`, justifying PEP 695 syntax.
+- PEP 695 — Type Parameter Syntax.

{ferro_orm-0.6.0 → ferro_orm-0.7.0}/pyproject.toml

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

{ferro_orm-0.6.0 → ferro_orm-0.7.0}/src/backend.rs

@@ -30,6 +30,8 @@ impl BackendKind {
 pub struct EngineHandle {
     backend: BackendKind,
     pool: BackendPool,
+    /// When false, Ferro skips the identity map for this connection (no lookup/register on load).
+    identity_map_enabled: bool,
 }
 
 #[derive(Clone, Debug)]
@@ -116,6 +118,7 @@ impl EngineHandle {
         Self {
             backend: BackendKind::Sqlite,
             pool: BackendPool::Sqlite(Arc::new(pool)),
+            identity_map_enabled: true,
         }
     }
 
@@ -123,9 +126,23 @@ impl EngineHandle {
         Self {
             backend: BackendKind::Postgres,
             pool: BackendPool::Postgres(Arc::new(pool)),
+            identity_map_enabled: true,
         }
     }
 
+    /// Returns whether this connection uses the identity map (singleton instances per PK).
+    #[must_use]
+    pub fn is_identity_map_enabled(&self) -> bool {
+        self.identity_map_enabled
+    }
+
+    /// Sets identity-map behavior for this handle (used by `connect(identity_map=...)`).
+    #[must_use]
+    pub fn with_identity_map_enabled(mut self, enabled: bool) -> Self {
+        self.identity_map_enabled = enabled;
+        self
+    }
+
     pub fn backend(&self) -> BackendKind {
         self.backend
     }

{ferro_orm-0.6.0 → ferro_orm-0.7.0}/src/connection.rs

@@ -187,7 +187,7 @@ async fn connect_engine_handle(
 /// # Errors
 /// Returns a `PyErr` if the connection fails or if auto-migration fails.
 #[pyfunction]
-#[pyo3(signature = (url, auto_migrate=false, name=None, default=false, max_connections=5, min_connections=0))]
+#[pyo3(signature = (url, auto_migrate=false, name=None, default=false, max_connections=5, min_connections=0, identity_map=true))]
 pub fn connect(
     py: Python<'_>,
     url: String,
@@ -196,6 +196,7 @@ pub fn connect(
     default: bool,
     max_connections: u32,
     min_connections: u32,
+    identity_map: bool,
 ) -> PyResult<Bound<'_, PyAny>> {
     let (connection_url, search_path) = split_search_path(&url);
     let redacted_url = redact_connection_url(&connection_url);
@@ -247,7 +248,8 @@ pub fn connect(
                 "DB Connection failed for {}: {}",
                 redacted_url, e
             ))
-        })?;
+        })?
+        .with_identity_map_enabled(identity_map);
 
         let engine_handle = Arc::new(engine_handle);
 

{ferro_orm-0.6.0 → ferro_orm-0.7.0}/src/ferro/__init__.py

@@ -60,6 +60,8 @@ async def connect(
     name: str | None = None,
     default: bool = False,
     pool: PoolConfig | None = None,
+    *,
+    identity_map: bool = True,
 ) -> None:
     """
     Establish a connection to the database.
@@ -70,6 +72,9 @@ async def connect(
         name: Optional connection name. Omitted connections register as "default".
         default: If True, make this named connection the default for unqualified operations.
         pool: Optional per-connection pool configuration.
+        identity_map: If True (default), keep a per-connection identity map so the same primary
+            key maps to a single Python instance. If False, each load returns fresh instances and
+            the map is not consulted (lower memory use; no ``a is b`` guarantees across loads).
     """
     from .relations import resolve_relationships
 
@@ -83,6 +88,7 @@ async def connect(
         default=default,
         max_connections=pool_config.max_connections,
         min_connections=pool_config.min_connections,
+        identity_map=identity_map,
     )
 
 

{ferro_orm-0.6.0 → ferro_orm-0.7.0}/src/ferro/_core.pyi

@@ -8,6 +8,8 @@ async def connect(
     default: bool = False,
     max_connections: int = 5,
     min_connections: int = 0,
+    *,
+    identity_map: bool = True,
 ) -> None: ...
 async def create_tables(using: Optional[str] = None) -> None: ...
 async def fetch_all(

{ferro_orm-0.6.0 → ferro_orm-0.7.0}/src/ferro/models.py

@@ -554,28 +554,33 @@ class Model(BaseModel, metaclass=ModelMetaclass):
         return await cls.create(**params), True
 
 
-class ModelConnection:
-    """Connection-bound ORM entrypoint returned by ``Model.using(name)``."""
+class ModelConnection[M: Model]:
+    """Connection-bound ORM entrypoint returned by ``Model.using(name)``.
 
-    def __init__(self, model_cls: type[Model], using: str) -> None:
-        self.model_cls = model_cls
-        self.using = using
+    Generic over the concrete model class so that every accessor preserves
+    the bound type — e.g. ``Transcript.using("service").get(pk)`` resolves
+    to ``Transcript | None`` rather than ``Model | None``.
+    """
+
+    def __init__(self, model_cls: type[M], connection_name: str) -> None:
+        self.model_cls: type[M] = model_cls
+        self._connection_name: str = connection_name
 
-    async def create(self, **fields: Any) -> Model:
+    async def create(self, **fields: Any) -> M:
         instance = self.model_cls(**fields)
-        await instance.save(using=self.using)
+        await instance.save(using=self._connection_name)
         return instance
 
-    async def all(self) -> list[Model]:
-        return await self.model_cls.all(using=self.using)
+    async def all(self) -> list[M]:
+        return await self.model_cls.all(using=self._connection_name)
 
-    def select(self) -> Query[Model]:
-        return Query(self.model_cls, using=self.using)
+    def select(self) -> Query[M]:
+        return Query(self.model_cls, using=self._connection_name)
 
-    def where(self, node: QueryNode) -> Query[Model]:
+    def where(self, node: QueryNode) -> Query[M]:
         return self.select().where(node)
 
-    async def get(self, pk: Any) -> Model | None:
+    async def get(self, pk: Any) -> M | None:
         pk_field_name = self.model_cls._primary_key_field_name()
         if pk_field_name is None:
             raise RuntimeError(
@@ -584,13 +589,13 @@ class ModelConnection:
 
         return await self.where(getattr(self.model_cls, pk_field_name) == pk).first()
 
-    async def bulk_create(self, instances: list[Model]) -> int:
-        return await self.model_cls.bulk_create(instances, using=self.using)
+    async def bulk_create(self, instances: list[M]) -> int:
+        return await self.model_cls.bulk_create(instances, using=self._connection_name)
 
     async def get_or_create(
         self, defaults: dict[str, Any] | None = None, **fields: Any
-    ) -> tuple[Model, bool]:
-        query = Query(self.model_cls, using=self.using)
+    ) -> tuple[M, bool]:
+        query = Query(self.model_cls, using=self._connection_name)
         for key, val in fields.items():
             query = query.where(getattr(self.model_cls, key) == val)
 
@@ -603,8 +608,8 @@ class ModelConnection:
 
     async def update_or_create(
         self, defaults: dict[str, Any] | None = None, **fields: Any
-    ) -> tuple[Model, bool]:
-        query = Query(self.model_cls, using=self.using)
+    ) -> tuple[M, bool]:
+        query = Query(self.model_cls, using=self._connection_name)
         for key, val in fields.items():
             query = query.where(getattr(self.model_cls, key) == val)
 
@@ -612,7 +617,7 @@ class ModelConnection:
         if instance:
             for key, val in (defaults or {}).items():
                 setattr(instance, key, val)
-            await instance.save(using=self.using)
+            await instance.save(using=self._connection_name)
             return instance, False
 
         params = {**fields, **(defaults or {})}