feat(backend): refactor mono repository

backend/db/base_repository.py

@@ -0,0 +1,109 @@
+# backend/db/base_repository.py
+from __future__ import annotations
+
+from typing import TypeVar, Generic, List, Sequence, Any, Mapping, Tuple
+from .connection import DatabaseConnection
+
+# Generic type for the model (your dataclasses such as Member, Service, …)
+T = TypeVar("T")
+
+
+class BaseRepository(Generic[T]):
+    """
+    Very small generic repository that knows how to:
+
+    * INSERT a dataclass‑like object (any object that implements ``to_dict`` and
+      ``from_row``)
+    * SELECT all rows from a table and turn them into model instances
+    * (optionally) UPDATE or DELETE rows – stubs are provided for future use
+    """
+
+    def __init__(self, db: DatabaseConnection):
+        self.db = db
+
+    # ------------------------------------------------------------------
+    # INSERT
+    # ------------------------------------------------------------------
+    def _insert(self, table: str, obj: T, pk_name: str) -> T:
+        """
+        Insert ``obj`` into ``table`` and populate the autoincrement primary‑key
+        field named ``pk_name`` on the original object.
+
+        The model **must** implement:
+        * ``to_dict() -> Mapping[str, Any]`` – returns a mapping of column →
+          value (including the PK, which we drop here)
+        * ``from_row(row: sqlite3.Row) -> Model`` – classmethod used by
+          ``_select_all``.
+        """
+        # 1️⃣ Turn the model into a plain dict and drop the PK column.
+        data: Mapping[str, Any] = obj.to_dict()          # type: ignore[attr-defined]
+        if pk_name not in data:
+            raise ValueError(f"Primary‑key column '{pk_name}' not found in model data.")
+        # Remove the autoincrement column – SQLite will fill it in.
+        data_without_pk = {k: v for k, v in data.items() if k != pk_name}
+
+        # 2️⃣ Build the column list and matching placeholders.
+        columns = ", ".join(data_without_pk.keys())
+        placeholders = ", ".join("?" for _ in data_without_pk)
+
+        sql = f"INSERT INTO {table} ({columns}) VALUES ({placeholders})"
+
+        # 3️⃣ Execute the statement with a *tuple* of values that matches the
+        #    number of placeholders.
+        cursor = self.db.execute(sql, tuple(data_without_pk.values()))
+
+        # 4️⃣ SQLite gives us the newly generated row‑id on the cursor.
+        setattr(obj, pk_name, cursor.lastrowid)          # type: ignore[attr-defined]
+
+        return obj
+
+    # ------------------------------------------------------------------
+    # SELECT ALL
+    # ------------------------------------------------------------------
+    def _select_all(self, table: str, model_cls: type[T]) -> List[T]:
+        """
+        Return every row from ``table`` as a list of ``model_cls`` instances.
+        ``model_cls`` must provide a ``from_row`` classmethod that accepts a
+        ``sqlite3.Row`` and returns an instantiated model.
+        """
+        rows = self.db.fetchall(f"SELECT * FROM {table}")
+        return [model_cls.from_row(r) for r in rows]    # type: ignore[attr-defined]
+
+    # ------------------------------------------------------------------
+    # OPTIONAL UPDATE helper (you can call it from concrete repos)
+    # ------------------------------------------------------------------
+    def _update(
+        self,
+        table: str,
+        pk_name: str,
+        pk_value: Any,
+        updates: Mapping[str, Any],
+    ) -> None:
+        """
+        Simple UPDATE helper.
+
+        Example:
+            repo._update(
+                table="Members",
+                pk_name="MemberId",
+                pk_value=42,
+                updates={"IsActive": 0, "Notes": "temporarily disabled"},
+            )
+        """
+        if not updates:
+            return  # nothing to do
+
+        set_clause = ", ".join(f"{col}=?" for col in updates)
+        sql = f"UPDATE {table} SET {set_clause} WHERE {pk_name} = ?"
+        params: Tuple[Any, ...] = tuple(updates.values()) + (pk_value,)
+        self.db.execute(sql, params)
+
+    # ------------------------------------------------------------------
+    # OPTIONAL DELETE helper
+    # ------------------------------------------------------------------
+    def _delete(self, table: str, pk_name: str, pk_value: Any) -> None:
+        """
+        Delete a row by primary key.
+        """
+        sql = f"DELETE FROM {table} WHERE {pk_name} = ?"
+        self.db.execute(sql, (pk_value,))