pgsqlasync2fast-fastapi 0.4.0__tar.gz → 0.4.1__tar.gz

{pgsqlasync2fast_fastapi-0.4.0/src/pgsqlasync2fast_fastapi.egg-info → pgsqlasync2fast_fastapi-0.4.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pgsqlasync2fast-fastapi
-Version: 0.4.0
+Version: 0.4.1
 Summary: Simple and fast PostgreSQL async module for FastAPI with multi-database support
 Author-email: Angel Daniel Sanchez Castillo <angeldaniel.sanchezcastillo@gmail.com>
 License: MIT License

{pgsqlasync2fast_fastapi-0.4.0 → pgsqlasync2fast_fastapi-0.4.1}/src/pgsqlasync2fast_fastapi/__init__.py

@@ -52,6 +52,8 @@ from pgsqlasync2fast_fastapi.seeder import (
     seed_all,
     # Shared idempotent insert-if-missing primitive
     insert_if_missing,
+    # Shared PostgreSQL sequence re-sync primitive
+    sync_table_sequence,
 )
 
 __all__ = [
@@ -90,4 +92,6 @@ __all__ = [
     "seed_all",
     # Shared idempotent insert-if-missing primitive
     "insert_if_missing",
+    # Shared PostgreSQL sequence re-sync primitive
+    "sync_table_sequence",
 ]

pgsqlasync2fast_fastapi-0.4.1/src/pgsqlasync2fast_fastapi/__version__.py

@@ -0,0 +1 @@
+__version__ = "0.4.1"

{pgsqlasync2fast_fastapi-0.4.0 → pgsqlasync2fast_fastapi-0.4.1}/src/pgsqlasync2fast_fastapi/seeder.py

@@ -593,6 +593,60 @@ def _resolve_load_order(manifest: dict[str, Any]) -> list[str]:
 # ============================================================================
 
 
+async def sync_table_sequence(
+    session: Any,
+    model_class: type,
+) -> None:
+    """
+    Re-sync a PostgreSQL table identity sequence to its current MAX(id).
+
+    The seeder inserts rows with explicit ``id`` values straight from the
+    manifest JSON. PostgreSQL's plain ``serial``/``sequence``-backed columns do
+    NOT advance the sequence when a row is inserted with an explicit id, so a
+    later sequence-backed insert (e.g. ``insert_if_missing``) can generate an
+    id that collides with an existing explicit-id row (UniqueViolation).
+
+    This issues one ``setval`` to ``MAX(id)`` after the explicit-id inserts so
+    the next auto-generated id continues past the seeded rows. It only runs
+    against PostgreSQL — SQLite assigns ``INTEGER PRIMARY KEY`` as max+1
+    automatically and has no incompatible sequence catalog, so it is a no-op
+    there.
+
+    Args:
+        session: SQLModel AsyncSession bound to the target DB.
+        model_class: The SQLModel/SQLAlchemy table class to re-sync.
+    """
+    from sqlalchemy import text
+
+    try:
+        bind = getattr(session, "bind", None)
+        if bind is None:
+            return
+        dialect = getattr(bind.dialect, "name", None)
+        if dialect != "postgresql":
+            return
+
+        table = model_class.__tablename__
+        seq = f"{table}_id_seq"
+        async with bind.begin() as conn:
+            max_id = await conn.scalar(
+                text(f'SELECT COALESCE(MAX(id), 0) FROM "{table}"')
+            )
+            if max_id:
+                await conn.execute(
+                    text("SELECT setval(:seq, :val)"),
+                    {"seq": seq, "val": max_id},
+                )
+                logger.info(
+                    f"Synced sequence '{seq}' to MAX(id)={max_id} "
+                    f"(table '{table}')"
+                )
+    except Exception as exc:  # pragma: no cover - defensive, non-fatal
+        logger.warning(
+            f"Could not re-sync sequence for '{model_class.__name__}': {exc}"
+        )
+
+
 async def _seed_table_idempotent(
     session: Any,
     table_name: str,
@@ -658,6 +712,9 @@ async def _seed_table_idempotent(
             logger.error(f"Failed to insert row in table '{table_name}': {e}")
             raise
 
+    if model_class is not None:
+        await sync_table_sequence(session, model_class)
+
     return rows_inserted, rows_skipped
 
 
@@ -727,6 +784,8 @@ async def _seed_table_idempotent_generic(
             logger.error(f"Failed to insert row in table '{table_name}': {e}")
             raise
 
+    await sync_table_sequence(session, model_class)
+
     return rows_inserted, rows_skipped
 
 

{pgsqlasync2fast_fastapi-0.4.0 → pgsqlasync2fast_fastapi-0.4.1/src/pgsqlasync2fast_fastapi.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pgsqlasync2fast-fastapi
-Version: 0.4.0
+Version: 0.4.1
 Summary: Simple and fast PostgreSQL async module for FastAPI with multi-database support
 Author-email: Angel Daniel Sanchez Castillo <angeldaniel.sanchezcastillo@gmail.com>
 License: MIT License

{pgsqlasync2fast_fastapi-0.4.0 → pgsqlasync2fast_fastapi-0.4.1}/src/pgsqlasync2fast_fastapi.egg-info/SOURCES.txt

@@ -31,4 +31,5 @@ src/pgsqlasync2fast_fastapi/skills/SKILL.md
 tests/test_completo.py
 tests/test_insert_if_missing.py
 tests/test_seeder.py
-tests/test_seeder_override.py
+tests/test_seeder_override.py
+tests/test_sync_sequence.py

pgsqlasync2fast_fastapi-0.4.1/tests/test_sync_sequence.py

@@ -0,0 +1,201 @@
+"""
+Tests for the shared PostgreSQL sequence re-sync primitive
+`sync_table_sequence` (pgsqlasync2fast-fastapi).
+
+The generic and by-id seeders insert rows with explicit ``id`` values from the
+manifest JSON. PostgreSQL's plain ``serial``/``sequence``-backed columns do not
+advance the sequence when a row is inserted with an explicit id, so a later
+sequence-backed insert (e.g. ``insert_if_missing``) can generate an id that
+collides with an existing explicit-id row (UniqueViolation).
+
+This module verifies:
+1. ``sync_table_sequence`` is a no-op on non-PostgreSQL dialects (SQLite).
+2. On PostgreSQL it issues ``setval`` to the table's ``MAX(id)``.
+3. Both seeding paths (``_seed_table_idempotent`` and
+   ``_seed_table_idempotent_generic``) call the primitive.
+
+Run with:
+  cd /Volumes/Desarrollo/Repos/Github/pgsqlasync2fast-fastapi \
+    && uv run pytest tests/test_sync_sequence.py -v
+"""
+
+from __future__ import annotations
+
+from unittest.mock import AsyncMock, MagicMock, patch
+
+import pytest
+from sqlalchemy import BigInteger
+from sqlalchemy.ext.asyncio import create_async_engine
+from sqlalchemy.ext.compiler import compiles
+from sqlmodel import Field, SQLModel
+from sqlmodel.ext.asyncio.session import AsyncSession
+
+
+@compiles(BigInteger, "sqlite")
+def _compile_bigint_sqlite(type_, compiler, **kw):
+    return "INTEGER"
+
+
+DB_URL = "sqlite+aiosqlite:///:memory:"
+
+
+class SeqFruit(SQLModel, table=True):
+    """Minimal SQLModel table to exercise the sequence helper."""
+
+    __tablename__ = "seq_fruits"
+
+    id: int | None = Field(default=None, primary_key=True)
+    name: str = Field(default="")
+
+
+async def _engine():
+    engine = create_async_engine(DB_URL, echo=False)
+    async with engine.begin() as conn:
+        await conn.run_sync(SQLModel.metadata.create_all)
+    return engine
+
+
+# ============================================================================
+# Unit: no-op on SQLite / selects dialect before setval
+# ============================================================================
+
+
+@pytest.mark.asyncio
+async def test_sync_sequence_noop_on_sqlite():
+    """On SQLite the helper returns without issuing any setval SQL."""
+    from pgsqlasync2fast_fastapi.seeder import sync_table_sequence
+
+    engine = await _engine()
+    async with AsyncSession(engine) as session:
+        # Should not raise, and must not attempt PostgreSQL sequence SQL.
+        await sync_table_sequence(session, SeqFruit)
+    await engine.dispose()
+
+
+@pytest.mark.asyncio
+async def test_sync_sequence_skips_non_postgresql():
+    """A non-PostgreSQL bind is detected and skipped before any query."""
+    from pgsqlasync2fast_fastapi.seeder import sync_table_sequence
+
+    # Bind that reports a non-PostgreSQL dialect with a tracked .begin()
+    bind = MagicMock()
+    bind.dialect.name = "sqlite"
+
+    session = AsyncMock()
+    session.bind = bind
+
+    await sync_table_sequence(session, SeqFruit)
+
+    bind.begin.assert_not_called()
+
+
+# ============================================================================
+# Unit: PostgreSQL path issues setval to MAX(id)
+# ============================================================================
+
+
+@pytest.mark.asyncio
+async def test_sync_sequence_issues_setval_to_max_id():
+    """On PostgreSQL the helper selects MAX(id) and runs setval."""
+    from pgsqlasync2fast_fastapi.seeder import sync_table_sequence
+
+    conn = AsyncMock()
+    conn.scalar = AsyncMock(return_value=11)
+    conn.execute = AsyncMock()
+
+    bind = MagicMock()
+    bind.dialect.name = "postgresql"
+    bind.begin.return_value.__aenter__.return_value = conn
+
+    session = AsyncMock()
+    session.bind = bind
+
+    await sync_table_sequence(session, SeqFruit)
+
+    # MAX(id) was read from the table
+    conn.scalar.assert_awaited_once()
+    assert '"seq_fruits"' in str(conn.scalar.await_args.args[0])
+    # setval ran with the sequence name and MAX(id)
+    conn.execute.assert_awaited_once()
+    args, kwargs = conn.execute.await_args
+    assert "setval" in str(args[0])
+    # parameters passed as second positional arg: {"seq": ..., "val": 11}
+    params = args[1] if len(args) > 1 else kwargs
+    assert params["val"] == 11
+    assert params["seq"] == "seq_fruits_id_seq"
+
+
+@pytest.mark.asyncio
+async def test_sync_sequence_skips_setval_when_table_empty():
+    """MAX(id) of 0 means no setval is issued (empty table)."""
+    from pgsqlasync2fast_fastapi.seeder import sync_table_sequence
+
+    conn = AsyncMock()
+    conn.scalar = AsyncMock(return_value=0)
+    conn.execute = AsyncMock()
+
+    bind = MagicMock()
+    bind.dialect.name = "postgresql"
+    bind.begin.return_value.__aenter__.return_value = conn
+
+    session = AsyncMock()
+    session.bind = bind
+
+    await sync_table_sequence(session, SeqFruit)
+
+    conn.execute.assert_not_called()
+
+
+# ============================================================================
+# Unit: both seeding paths invoke the primitive
+# ============================================================================
+
+
+@pytest.mark.asyncio
+async def test_idempotent_seeder_calls_sync_sequence():
+    """_seed_table_idempotent invokes sync_table_sequence at the end."""
+    from pgsqlasync2fast_fastapi.seeder import _seed_table_idempotent
+
+    session = AsyncMock()
+    exec_result = MagicMock()
+    exec_result.one_or_none = MagicMock(return_value=None)
+    session.exec = AsyncMock(return_value=exec_result)
+    session.add = MagicMock()
+    session.commit = AsyncMock()
+    session.rollback = AsyncMock()
+
+    with patch(
+        "pgsqlasync2fast_fastapi.seeder.sync_table_sequence",
+        new=AsyncMock(),
+    ) as mock_sync:
+        inserted, skipped = await _seed_table_idempotent(
+            session, "seq_fruits", [{"id": 1, "name": "apple"}], SeqFruit
+        )
+
+    assert inserted == 1
+    mock_sync.assert_awaited_once_with(session, SeqFruit)
+
+
+@pytest.mark.asyncio
+async def test_generic_seeder_calls_sync_sequence():
+    """_seed_table_idempotent_generic invokes sync_table_sequence at the end."""
+    from pgsqlasync2fast_fastapi.seeder import _seed_table_idempotent_generic
+
+    session = AsyncMock()
+    exec_result = MagicMock()
+    exec_result.one_or_none = MagicMock(return_value=None)
+    session.exec = AsyncMock(return_value=exec_result)
+    session.add = MagicMock()
+    session.commit = AsyncMock()
+    session.rollback = AsyncMock()
+
+    with patch(
+        "pgsqlasync2fast_fastapi.seeder.sync_table_sequence",
+        new=AsyncMock(),
+    ) as mock_sync:
+        inserted, skipped = await _seed_table_idempotent_generic(
+            session, "seq_fruits", [{"id": 1, "name": "apple"}], SeqFruit
+        )
+
+    assert inserted == 1
+    mock_sync.assert_awaited_once_with(session, SeqFruit)

pgsqlasync2fast_fastapi-0.4.0/src/pgsqlasync2fast_fastapi/__version__.py

@@ -1 +0,0 @@
-__version__ = "0.4.0"