csrd-repository 0.1.0__tar.gz

csrd_repository-0.1.0/.gitignore

@@ -0,0 +1,217 @@
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[codz]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py.cover
+.hypothesis/
+.pytest_cache/
+cover/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+.pybuilder/
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+#   For a library or package, you might want to ignore these files since the code is
+#   intended to run in multiple environments; otherwise, check them in:
+# .python-version
+
+# pipenv
+#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
+#   However, in case of collaboration, if having platform-specific dependencies or dependencies
+#   having no cross-platform support, pipenv may install dependencies that don't work, or not
+#   install all needed dependencies.
+#Pipfile.lock
+
+# UV
+#   Similar to Pipfile.lock, it is generally recommended to include uv.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+#uv.lock
+
+# poetry
+#   Similar to Pipfile.lock, it is generally recommended to include poetry.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+#   https://python-poetry.org/docs/basic-usage/#commit-your-poetrylock-file-to-version-control
+#poetry.lock
+#poetry.toml
+
+# pdm
+#   Similar to Pipfile.lock, it is generally recommended to include pdm.lock in version control.
+#   pdm recommends including project-wide configuration in pdm.toml, but excluding .pdm-python.
+#   https://pdm-project.org/en/latest/usage/project/#working-with-version-control
+#pdm.lock
+#pdm.toml
+.pdm-python
+.pdm-build/
+
+# pixi
+#   Similar to Pipfile.lock, it is generally recommended to include pixi.lock in version control.
+#pixi.lock
+#   Pixi creates a virtual environment in the .pixi directory, just like venv module creates one
+#   in the .venv directory. It is recommended not to include this directory in version control.
+.pixi
+
+# PEP 582; used by e.g. github.com/David-OConnor/pyflow and github.com/pdm-project/pdm
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.envrc
+.venv
+/env/
+/venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+# pytype static type analyzer
+.pytype/
+
+# Cython debug symbols
+cython_debug/
+
+# PyCharm
+#  JetBrains specific template is maintained in a separate JetBrains.gitignore that can
+#  be found at https://github.com/github/gitignore/blob/main/Global/JetBrains.gitignore
+#  and can be added to the global gitignore or merged into this file.  For a more nuclear
+#  option (not recommended) you can uncomment the following to ignore the entire idea folder.
+#.idea/
+
+# Abstra
+# Abstra is an AI-powered process automation framework.
+# Ignore directories containing user credentials, local state, and settings.
+# Learn more at https://abstra.io/docs
+.abstra/
+
+# Visual Studio Code
+#  Visual Studio Code specific template is maintained in a separate VisualStudioCode.gitignore
+#  that can be found at https://github.com/github/gitignore/blob/main/Global/VisualStudioCode.gitignore
+#  and can be added to the global gitignore or merged into this file. However, if you prefer,
+#  you could uncomment the following to ignore the entire vscode folder
+# .vscode/
+
+# Ruff stuff:
+.ruff_cache/
+
+# PyPI configuration file
+.pypirc
+
+# Cursor
+#  Cursor is an AI-powered code editor. `.cursorignore` specifies files/directories to
+#  exclude from AI features like autocomplete and code analysis. Recommended for sensitive data
+#  refer to https://docs.cursor.com/context/ignore-files
+.cursorignore
+.cursorindexingignore
+
+# Marimo
+marimo/_static/
+marimo/_lsp/
+__marimo__/
+
+*.db
+
+
+# Import linter cache
+.import_linter_cache/
+
+# IDE
+.idea/
+.idea/*

csrd_repository-0.1.0/PKG-INFO

@@ -0,0 +1,13 @@
+Metadata-Version: 2.4
+Name: csrd-repository
+Version: 0.1.0
+Summary: Base repository and database adapter abstractions
+Project-URL: Repository, https://github.com/csrd-api/fastapi-common
+Project-URL: Documentation, https://github.com/csrd-api/fastapi-common/tree/main/packages/repository
+Project-URL: Changelog, https://github.com/csrd-api/fastapi-common/blob/main/CHANGELOG.md
+License: MIT
+Requires-Python: >=3.12
+Requires-Dist: aiosqlite<1,>=0.21
+Requires-Dist: csrd-models
+Provides-Extra: sql
+Requires-Dist: sqlalchemy<3,>=2.0; extra == 'sql'

csrd_repository-0.1.0/README.md

@@ -0,0 +1,23 @@
+ # csrd-repository
+
+Base repository and database adapter abstractions for FastAPI microservices.
+
+**Package**: `csrd.repository` · **Import**: `from csrd.repository import BaseRepository, SQLiteAdapter`
+
+## What's included
+
+- `BaseRepository` — abstract repository with model parsing (requires an adapter)
+- `ABCDatabaseAdapter` / `DBProtocol` — async database adapter abstraction with lifecycle (`connect()` / `close()` / `async with`)
+- `SQLiteAdapter` — async SQLite implementation via aiosqlite (persistent connection, atomic upsert)
+- `ExecuteResult` — immutable snapshot of query metadata (replaces raw cursor return)
+- Optional `sqlalchemy` integration for query building (`pip install csrd-repository[sql]`)
+
+## Installation
+
+```bash
+uv pip install "csrd-repository @ git+ssh://git@github.com/csrd-api/fastapi-common.git#subdirectory=packages/repository"
+```
+
+## Dependencies
+
+- `csrd-models` (Tier 2)

csrd_repository-0.1.0/pyproject.toml

@@ -0,0 +1,28 @@
+[project]
+name = "csrd-repository"
+version = "0.1.0"
+description = "Base repository and database adapter abstractions"
+license = { text = "MIT" }
+requires-python = ">=3.12"
+dependencies = [
+    "aiosqlite>=0.21,<1",
+    "csrd-models",
+]
+
+[project.optional-dependencies]
+sql = ["sqlalchemy>=2.0,<3"]
+
+[tool.uv.sources]
+csrd-models = { workspace = true }
+
+[project.urls]
+Repository = "https://github.com/csrd-api/fastapi-common"
+Documentation = "https://github.com/csrd-api/fastapi-common/tree/main/packages/repository"
+Changelog = "https://github.com/csrd-api/fastapi-common/blob/main/CHANGELOG.md"
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/csrd"]

csrd_repository-0.1.0/src/csrd/repository/__init__.py

@@ -0,0 +1,20 @@
+from ._base_repository import BaseRepository
+from ._database_adapter import ABCDatabaseAdapter, DBProtocol
+from .execute_result import ExecuteResult
+from .protocols import CursorLike, RowLike
+from .sqlite_adapter import SQLiteAdapter
+from .types import DBParams, DBQuery
+from .utils import unpack_params
+
+__all__ = [
+    "ABCDatabaseAdapter",
+    "BaseRepository",
+    "CursorLike",
+    "DBParams",
+    "DBProtocol",
+    "DBQuery",
+    "ExecuteResult",
+    "RowLike",
+    "SQLiteAdapter",
+    "unpack_params",
+]

csrd_repository-0.1.0/src/csrd/repository/_base_repository.py

@@ -0,0 +1,68 @@
+from collections.abc import Sequence
+from typing import Any
+
+from csrd.models.model_parser import ModelParserMixin
+
+from ._database_adapter import DBProtocol
+from .types import DBQuery
+
+
+def _compile(query: DBQuery, params: dict[str, Any] | None) -> tuple[str, dict[str, Any] | None]:
+    """Convert a query (raw SQL *or* SQLAlchemy Executable) into (sql_string, params)."""
+    if isinstance(query, str):
+        return query, params
+
+    # SQLAlchemy Executable — compile to SQL + extract bound params
+    compiled = query.compile(compile_kwargs={"literal_binds": False})
+    sql = str(compiled)
+    compiled_params = dict(compiled.params) if compiled.params else {}
+    if params:
+        compiled_params.update(params)
+    return sql, compiled_params or None
+
+
+class BaseRepository(ModelParserMixin):
+    _adapter: DBProtocol
+
+    def __init__(self, adapter: DBProtocol):
+        if adapter is None:
+            raise TypeError("BaseRepository requires a database adapter — got None")
+        self._adapter = adapter
+        super().__init__(extractor=self._adapter.extractor)
+
+    @property
+    def extract(self):
+        return self._adapter.extractor.extract
+
+    async def fetch_one(self, query: DBQuery, params: dict[str, Any] | None = None) -> Any | None:
+        sql, resolved = _compile(query, params)
+        raw = await self._adapter.fetch_one(sql, resolved)
+        return self._resolve_payload(raw)
+
+    async def fetch_all(
+        self, query: DBQuery, params: dict[str, Any] | None = None
+    ) -> Sequence[Any]:
+        sql, resolved = _compile(query, params)
+        raw = await self._adapter.fetch_all(sql, resolved)
+        result = self._resolve_payload(raw)
+        return list(result) if isinstance(result, (list, tuple)) else [result]
+
+    async def execute(self, query: DBQuery, params: dict[str, Any] | None = None) -> Any:
+        sql, resolved = _compile(query, params)
+        return await self._adapter.execute(sql, resolved)
+
+    async def execute_returning(self, query: DBQuery, params: dict[str, Any] | None = None) -> Any:
+        sql, resolved = _compile(query, params)
+        return await self._adapter.execute_returning(sql, resolved)
+
+    async def insert(self, table: str, values: dict[str, Any], *args, **kwargs) -> Any:
+        return await self._adapter.insert(table, values, *args, **kwargs)
+
+    async def update(self, table: str, values: dict[str, Any], where: dict[str, Any]) -> int:
+        return await self._adapter.update(table, values, where)
+
+    async def upsert(self, table: str, values: dict[str, Any], where: dict[str, Any]) -> int:
+        return await self._adapter.upsert(table, values, where)
+
+    async def delete(self, table: str, where: dict[str, Any]) -> int:
+        return await self._adapter.delete(table, where)

csrd_repository-0.1.0/src/csrd/repository/_database_adapter.py

@@ -0,0 +1,140 @@
+from abc import ABC, abstractmethod
+from collections.abc import Sequence
+from types import TracebackType
+from typing import Any, Protocol, Self
+
+from csrd.models.model_parser import PayloadExtractor
+
+from .execute_result import ExecuteResult
+
+
+class DBProtocol(Protocol):
+    """Protocol defining a pluggable interface for database operations.
+
+    Implementations must support an async lifecycle (``connect`` / ``close``)
+    and the standard query / mutation methods.
+    """
+
+    @property
+    def extractor(self) -> PayloadExtractor:
+        """The extractor used to parse raw DB rows into structured data."""
+        ...
+
+    async def connect(self) -> None:
+        """Open the underlying database connection (or pool)."""
+        ...
+
+    async def close(self) -> None:
+        """Close the underlying database connection (or pool)."""
+        ...
+
+    async def fetch_one(self, query: str, params: dict[str, Any] | None = None) -> dict | None:
+        """Fetch a single row from the database."""
+        ...
+
+    async def fetch_all(self, query: str, params: dict[str, Any] | None = None) -> Sequence[dict]:
+        """Fetch multiple rows from the database."""
+        ...
+
+    async def execute(self, query: str, params: dict[str, Any] | None = None) -> int:
+        """Execute a DML statement and return the number of rows affected."""
+        ...
+
+    async def execute_returning(
+        self, query: str, params: dict[str, Any] | None = None
+    ) -> ExecuteResult:
+        """Execute a statement and return an ``ExecuteResult`` with metadata."""
+        ...
+
+    async def insert(self, table: str, values: dict[str, Any]) -> Any:
+        """Insert a new row into the specified table."""
+        ...
+
+    async def update(self, table: str, values: dict[str, Any], where: dict[str, Any]) -> int:
+        """Update existing rows in the table matching the condition."""
+        ...
+
+    async def upsert(self, table: str, values: dict[str, Any], where: dict[str, Any]) -> int:
+        """Insert or update a row depending on whether the condition is met."""
+        ...
+
+    async def delete(self, table: str, where: dict[str, Any]) -> int:
+        """Delete rows matching the condition."""
+        ...
+
+
+class ABCDatabaseAdapter(ABC, DBProtocol):
+    """Abstract base for concrete database adapters.
+
+    Subclasses must implement ``connect``, ``close``, and all query methods.
+    The ``async with`` context-manager protocol is provided for free.
+    """
+
+    _dsn: str
+    _extractor: PayloadExtractor
+
+    def __init__(self, dsn: str, extractor: PayloadExtractor):
+        self._dsn = dsn
+        self._extractor = extractor
+
+    @property
+    def extractor(self) -> PayloadExtractor:
+        return self._extractor
+
+    # ── Lifecycle ────────────────────────────────────────────────────────
+
+    @abstractmethod
+    async def connect(self) -> None:
+        """Open the underlying connection (or pool). Idempotent."""
+
+    @abstractmethod
+    async def close(self) -> None:
+        """Close the underlying connection (or pool). Idempotent."""
+
+    async def __aenter__(self) -> Self:
+        await self.connect()
+        return self
+
+    async def __aexit__(
+        self,
+        exc_type: type[BaseException] | None,
+        exc_val: BaseException | None,
+        exc_tb: TracebackType | None,
+    ) -> None:
+        await self.close()
+
+    # ── Query interface ──────────────────────────────────────────────────
+
+    @abstractmethod
+    async def fetch_one(self, query: str, params: dict[str, Any] | None = None) -> dict | None:
+        """Fetch a single row from the database."""
+
+    @abstractmethod
+    async def fetch_all(self, query: str, params: dict[str, Any] | None = None) -> Sequence[dict]:
+        """Fetch multiple rows from the database."""
+
+    @abstractmethod
+    async def execute(self, query: str, params: dict[str, Any] | None = None) -> int:
+        """Execute a DML statement and return the number of rows affected."""
+
+    @abstractmethod
+    async def execute_returning(
+        self, query: str, params: dict[str, Any] | None = None
+    ) -> ExecuteResult:
+        """Execute a statement and return an ``ExecuteResult`` with metadata."""
+
+    @abstractmethod
+    async def insert(self, table: str, values: dict[str, Any]) -> Any:
+        """Insert a new row into the specified table."""
+
+    @abstractmethod
+    async def update(self, table: str, values: dict[str, Any], where: dict[str, Any]) -> int:
+        """Update existing rows in the table matching the condition."""
+
+    @abstractmethod
+    async def upsert(self, table: str, values: dict[str, Any], where: dict[str, Any]) -> int:
+        """Insert or update a row depending on whether the condition is met."""
+
+    @abstractmethod
+    async def delete(self, table: str, where: dict[str, Any]) -> int:
+        """Delete rows matching the condition."""

csrd_repository-0.1.0/src/csrd/repository/execute_result.py

@@ -0,0 +1,14 @@
+from dataclasses import dataclass
+
+
+@dataclass(frozen=True, slots=True)
+class ExecuteResult:
+    """Immutable snapshot of metadata from an executed SQL statement.
+
+    Returned by ``execute_returning`` so callers can inspect ``lastrowid``
+    and ``rowcount`` without holding a reference to a raw database cursor
+    (which may be invalidated when the connection or transaction closes).
+    """
+
+    rowcount: int
+    lastrowid: int | None = None

csrd_repository-0.1.0/src/csrd/repository/protocols.py

@@ -0,0 +1,44 @@
+"""Backend-agnostic protocols for database cursor and row objects."""
+
+from collections.abc import Iterator
+from typing import Any, Protocol, runtime_checkable
+
+
+@runtime_checkable
+class CursorLike(Protocol):
+    """Backend-agnostic contract for DB cursor-like objects."""
+
+    @property
+    def rowcount(self) -> int:
+        """Number of rows affected by last operation."""
+        ...
+
+    @property
+    def lastrowid(self) -> int | None:
+        """ID of the last inserted row, if applicable."""
+        ...
+
+    def __getitem__(self, key: Any) -> Any:
+        """Support for key or index access to rows."""
+        ...
+
+    def __iter__(self) -> Iterator[Any]:
+        """Support for iteration over rows."""
+        ...
+
+
+@runtime_checkable
+class RowLike(Protocol):
+    """Represents a single row from a database cursor result."""
+
+    def __getitem__(self, key: Any) -> Any:
+        """Allows key or index-based access to column values."""
+        ...
+
+    def keys(self) -> list[str]:
+        """Returns a list of column names for key-based access."""
+        ...
+
+    def __iter__(self) -> Iterator[Any]:
+        """Allows iteration over column values."""
+        ...

csrd_repository-0.1.0/src/csrd/repository/sqlite_adapter.py

@@ -0,0 +1,164 @@
+from collections.abc import Sequence
+from typing import Any
+
+import aiosqlite
+
+from csrd.models import BaseModel
+from csrd.models.model_parser import PayloadExtractor
+
+from ._database_adapter import ABCDatabaseAdapter
+from .execute_result import ExecuteResult
+from .types import DBParams
+
+
+class SQLiteExtractor(PayloadExtractor):
+    def extract(self, source: Any) -> dict | list[dict]:
+        """
+        Extracts payload from raw SQLite rows. Assumes source is either:
+        - A single row as a dict
+        - A list of rows (each as a dict)
+        - Already a dict/list
+        """
+        if isinstance(source, list):
+            return [
+                {key: row[key] for key in row.keys()}  # noqa: SIM118 — sqlite3.Row iterates values, not keys
+                for row in source
+                if hasattr(row, "keys")
+            ]
+        if hasattr(source, "keys") and hasattr(source, "__getitem__"):
+            # Row-like object from SQLite with keys
+            return {key: source[key] for key in source.keys()}  # noqa: SIM118
+        if isinstance(source, tuple) and hasattr(source, "description"):
+            # Raw cursor tuples with description - unsupported in this extractor
+            raise ValueError("Raw tuples with description unsupported. Use dict_factory.")
+        return dict(source)  # type: ignore[call-overload]
+
+
+class SQLiteAdapter(ABCDatabaseAdapter):
+    """Async SQLite adapter with a persistent connection.
+
+    Use as an async context manager or call ``connect()`` / ``close()``
+    explicitly::
+
+        async with SQLiteAdapter("app.db") as db:
+            row = await db.fetch_one("SELECT ...")
+
+    The adapter opens a **single** ``aiosqlite`` connection and reuses it
+    for all queries.  Call ``close()`` (or exit the context manager) when
+    the application shuts down.
+    """
+
+    _db: aiosqlite.Connection | None
+
+    def __init__(self, db_path: str | None = None, *, extractor: PayloadExtractor | None = None):
+        """Initialise with a file path or ``:memory:`` (default)."""
+        super().__init__(dsn=db_path or ":memory:", extractor=extractor or SQLiteExtractor())
+        self._db = None
+
+    # ── Lifecycle ────────────────────────────────────────────────────────
+
+    async def connect(self) -> None:
+        """Open the SQLite connection. Idempotent."""
+        if self._db is not None:
+            return
+        self._db = await aiosqlite.connect(self._dsn)
+        self._db.row_factory = aiosqlite.Row
+
+    async def close(self) -> None:
+        """Close the SQLite connection. Idempotent."""
+        if self._db is not None:
+            await self._db.close()
+            self._db = None
+
+    @property
+    def _connection(self) -> aiosqlite.Connection:
+        """Return the live connection or raise if not connected."""
+        if self._db is None:
+            raise RuntimeError(
+                "SQLiteAdapter is not connected. "
+                "Call await adapter.connect() or use 'async with adapter:'."
+            )
+        return self._db
+
+    # ── Query interface ──────────────────────────────────────────────────
+
+    async def fetch_one(self, query: str, params: DBParams = None) -> dict | None:
+        """Fetch a single row and parse it via the extractor."""
+        async with self._connection.execute(query, params or {}) as cursor:
+            row = await cursor.fetchone()
+            return self.extractor.extract(row) if row else None
+
+    async def fetch_all(self, query: str, params: DBParams = None) -> Sequence[dict]:
+        """Fetch multiple rows and parse them via the extractor."""
+        async with self._connection.execute(query, params or {}) as cursor:
+            rows = await cursor.fetchall()
+            return list(self.extractor.extract(rows))  # type: ignore[arg-type]
+
+    async def execute(self, query: str, params: DBParams = None) -> int:
+        """Execute a DML statement and return the number of affected rows."""
+        cursor = await self._connection.execute(query, params or {})
+        await self._connection.commit()
+        return cursor.rowcount
+
+    async def execute_returning(self, query: str, params: DBParams = None) -> ExecuteResult:
+        """Execute a statement and return an ``ExecuteResult`` snapshot."""
+        cursor = await self._connection.execute(query, params or {})
+        await self._connection.commit()
+        return ExecuteResult(rowcount=cursor.rowcount, lastrowid=cursor.lastrowid)
+
+    async def insert(
+        self, table: str, values: dict[str, Any], *, model: type[BaseModel] | None = None
+    ) -> Any:
+        """Insert a row. Optionally return a model instance."""
+        keys = ", ".join(values.keys())
+        placeholders = ", ".join(f":{key}" for key in values)
+        query = f"INSERT INTO {table} ({keys}) VALUES ({placeholders})"
+        result = await self.execute_returning(query, values)
+
+        last_id = result.lastrowid
+        if model:
+            return model(**{**values, "id": last_id})  # type: ignore[misc]
+        values["id"] = last_id
+        return values
+
+    async def update(self, table: str, values: dict[str, Any], where: dict[str, Any]) -> int:
+        """Update rows matching the WHERE condition."""
+        set_clause = ", ".join(f"{key} = :{key}" for key in values)
+        where_clause = " AND ".join(f"{key} = :where_{key}" for key in where)
+        combined_params = {**values, **{f"where_{k}": v for k, v in where.items()}}
+        query = f"UPDATE {table} SET {set_clause} WHERE {where_clause}"
+        return await self.execute(query, combined_params)
+
+    async def upsert(self, table: str, values: dict[str, Any], where: dict[str, Any]) -> int:
+        """Atomic upsert via ``INSERT ... ON CONFLICT``.
+
+        ``where`` keys identify the conflict target (unique columns).
+        ``values`` contains the full row data to insert or update.
+        """
+        all_values = {**where, **values}
+        keys = ", ".join(all_values.keys())
+        placeholders = ", ".join(f":{k}" for k in all_values)
+        conflict_cols = ", ".join(where.keys())
+
+        # Columns to update on conflict (everything except the conflict keys)
+        update_cols = [k for k in values if k not in where]
+
+        if update_cols:
+            set_clause = ", ".join(f"{k} = excluded.{k}" for k in update_cols)
+            query = (
+                f"INSERT INTO {table} ({keys}) VALUES ({placeholders}) "
+                f"ON CONFLICT({conflict_cols}) DO UPDATE SET {set_clause}"
+            )
+        else:
+            query = (
+                f"INSERT INTO {table} ({keys}) VALUES ({placeholders}) "
+                f"ON CONFLICT({conflict_cols}) DO NOTHING"
+            )
+
+        return await self.execute(query, all_values)
+
+    async def delete(self, table: str, where: dict[str, Any]) -> int:
+        """Delete rows matching the WHERE condition."""
+        where_clause = " AND ".join(f"{key} = :{key}" for key in where)
+        query = f"DELETE FROM {table} WHERE {where_clause}"
+        return await self.execute(query, where)

csrd_repository-0.1.0/src/csrd/repository/types.py

@@ -0,0 +1,15 @@
+from __future__ import annotations
+
+from collections.abc import Mapping, Sequence
+from typing import Any
+
+# Either a dict of named params (for SQLite)
+# or an ordered sequence of values (for Postgres)
+DBParams = Mapping[str, Any] | Sequence[Any] | None
+
+try:
+    from sqlalchemy.sql.expression import Executable
+
+    DBQuery = str | Executable
+except ImportError:  # sqlalchemy not installed
+    DBQuery = str  # type: ignore[misc]

csrd_repository-0.1.0/src/csrd/repository/utils.py

@@ -0,0 +1,15 @@
+from collections.abc import Mapping, Sequence
+from typing import Any
+
+from .types import DBParams
+
+
+def unpack_params(params: DBParams) -> Sequence[Any]:
+    """Unpack params into a positional sequence (used by Postgres)."""
+    if params is None:
+        return []
+    if isinstance(params, Mapping):
+        return list(params.values())
+    if isinstance(params, Sequence):
+        return list(params)
+    raise TypeError(f"Unsupported params type: {type(params)}")

csrd_repository-0.1.0/tests/test_sqlite_adapter.py

@@ -0,0 +1,138 @@
+"""Tests for SQLiteAdapter."""
+
+import aiosqlite
+import pytest
+
+from csrd.repository.sqlite_adapter import SQLiteAdapter, SQLiteExtractor
+
+
+@pytest.fixture
+async def seeded_adapter(tmp_path):
+    """Adapter with a pre-seeded table using the async context manager lifecycle."""
+    db_path = str(tmp_path / "test.db")
+
+    async with aiosqlite.connect(db_path) as db:
+        db.row_factory = aiosqlite.Row
+        await db.execute(
+            "CREATE TABLE items (id INTEGER PRIMARY KEY AUTOINCREMENT, name TEXT UNIQUE, price REAL)"
+        )
+        await db.execute("INSERT INTO items (name, price) VALUES ('Widget', 9.99)")
+        await db.execute("INSERT INTO items (name, price) VALUES ('Gadget', 19.99)")
+        await db.commit()
+
+    async with SQLiteAdapter(db_path) as adapter:
+        yield adapter
+
+
+class TestSQLiteExtractor:
+    def test_extract_dict(self):
+        ext = SQLiteExtractor()
+        result = ext.extract({"name": "test", "value": 42})
+        assert result == {"name": "test", "value": 42}
+
+    def test_extract_list_passthrough(self):
+        ext = SQLiteExtractor()
+        result = ext.extract([{"name": "a"}, {"name": "b"}])
+        # With real Row objects this extracts keys; with plain dicts it handles gracefully
+        assert isinstance(result, list)
+
+
+class TestSQLiteAdapter:
+    @pytest.mark.asyncio
+    async def test_not_connected_raises(self, tmp_path):
+        adapter = SQLiteAdapter(str(tmp_path / "unused.db"))
+        with pytest.raises(RuntimeError, match="not connected"):
+            await adapter.fetch_one("SELECT 1")
+
+    @pytest.mark.asyncio
+    async def test_connect_is_idempotent(self, tmp_path):
+        adapter = SQLiteAdapter(str(tmp_path / "idem.db"))
+        await adapter.connect()
+        db1 = adapter._db
+        await adapter.connect()  # second call is a no-op
+        assert adapter._db is db1
+        await adapter.close()
+
+    @pytest.mark.asyncio
+    async def test_insert_and_fetch(self, seeded_adapter):
+        result = await seeded_adapter.fetch_one(
+            "SELECT * FROM items WHERE name = :name", {"name": "Widget"}
+        )
+        assert result is not None
+        assert result["name"] == "Widget"
+        assert result["price"] == 9.99
+
+    @pytest.mark.asyncio
+    async def test_fetch_all(self, seeded_adapter):
+        results = await seeded_adapter.fetch_all("SELECT * FROM items")
+        assert len(results) == 2
+
+    @pytest.mark.asyncio
+    async def test_fetch_one_missing(self, seeded_adapter):
+        result = await seeded_adapter.fetch_one(
+            "SELECT * FROM items WHERE name = :name", {"name": "NonExistent"}
+        )
+        assert result is None
+
+    @pytest.mark.asyncio
+    async def test_insert(self, seeded_adapter):
+        result = await seeded_adapter.insert("items", {"name": "New", "price": 5.0})
+        assert result["name"] == "New"
+        assert "id" in result
+
+    @pytest.mark.asyncio
+    async def test_update(self, seeded_adapter):
+        rows = await seeded_adapter.update("items", {"price": 99.99}, {"name": "Widget"})
+        assert rows == 1
+        updated = await seeded_adapter.fetch_one(
+            "SELECT * FROM items WHERE name = :name", {"name": "Widget"}
+        )
+        assert updated["price"] == 99.99
+
+    @pytest.mark.asyncio
+    async def test_delete(self, seeded_adapter):
+        rows = await seeded_adapter.delete("items", {"name": "Widget"})
+        assert rows == 1
+        remaining = await seeded_adapter.fetch_all("SELECT * FROM items")
+        assert len(remaining) == 1
+
+    @pytest.mark.asyncio
+    async def test_upsert_insert(self, seeded_adapter):
+        rows = await seeded_adapter.upsert(
+            "items", {"name": "Brand New", "price": 1.0}, {"name": "Brand New"}
+        )
+        assert rows == 1
+        result = await seeded_adapter.fetch_one(
+            "SELECT * FROM items WHERE name = :name", {"name": "Brand New"}
+        )
+        assert result is not None
+
+    @pytest.mark.asyncio
+    async def test_upsert_update(self, seeded_adapter):
+        rows = await seeded_adapter.upsert(
+            "items", {"name": "Widget", "price": 0.01}, {"name": "Widget"}
+        )
+        assert rows == 1
+        result = await seeded_adapter.fetch_one(
+            "SELECT * FROM items WHERE name = :name", {"name": "Widget"}
+        )
+        assert result["price"] == 0.01
+
+    @pytest.mark.asyncio
+    async def test_execute(self, seeded_adapter):
+        rowcount = await seeded_adapter.execute(
+            "DELETE FROM items WHERE name = :name", {"name": "Widget"}
+        )
+        assert rowcount == 1
+
+    @pytest.mark.asyncio
+    async def test_execute_returning(self, seeded_adapter):
+        from csrd.repository import ExecuteResult
+
+        result = await seeded_adapter.execute_returning(
+            "INSERT INTO items (name, price) VALUES (:name, :price)",
+            {"name": "Thingamajig", "price": 3.50},
+        )
+        assert isinstance(result, ExecuteResult)
+        assert result.lastrowid is not None
+        assert result.rowcount == 1