Refactor: implemented Repository Factory and Async Mutator Engine. Decoupled storage logic and enforced Dependency Injection across CLI and Web API. Updated documentation.

decnet/web/db/factory.py

@@ -0,0 +1,18 @@
+from typing import Any
+from decnet.env import os
+from decnet.web.db.repository import BaseRepository
+
+def get_repository(**kwargs: Any) -> BaseRepository:
+    """Factory function to instantiate the correct repository implementation based on environment."""
+    db_type = os.environ.get("DECNET_DB_TYPE", "sqlite").lower()
+
+    if db_type == "sqlite":
+        from decnet.web.db.sqlite.repository import SQLiteRepository
+        return SQLiteRepository(**kwargs)
+    elif db_type == "mysql":
+        # Placeholder for future implementation
+        # from decnet.web.db.mysql.repository import MySQLRepository
+        # return MySQLRepository()
+        raise NotImplementedError("MySQL support is planned but not yet implemented.")
+    else:
+        raise ValueError(f"Unsupported database type: {db_type}")

decnet/web/db/models.py

@@ -22,7 +22,7 @@ class Log(SQLModel, table=True):
     event_type: str = Field(index=True)
     attacker_ip: str = Field(index=True)
     raw_line: str
-    fields: str 
+    fields: str
     msg: Optional[str] = None
 
 class Bounty(SQLModel, table=True):
@@ -35,6 +35,12 @@ class Bounty(SQLModel, table=True):
     bounty_type: str = Field(index=True)
     payload: str
 
+
+class State(SQLModel, table=True):
+    __tablename__ = "state"
+    key: str = Field(primary_key=True)
+    value: str  # Stores JSON serialized DecnetConfig or other state blobs
+
 # --- API Request/Response Models (Pydantic) ---
 
 class Token(BaseModel):

decnet/web/db/repository.py

@@ -17,9 +17,9 @@ class BaseRepository(ABC):
 
     @abstractmethod
     async def get_logs(
-        self, 
-        limit: int = 50, 
-        offset: int = 0, 
+        self,
+        limit: int = 50,
+        offset: int = 0,
         search: Optional[str] = None
     ) -> list[dict[str, Any]]:
         """Retrieve paginated log entries."""
@@ -67,9 +67,9 @@ class BaseRepository(ABC):
 
     @abstractmethod
     async def get_bounties(
-        self, 
-        limit: int = 50, 
-        offset: int = 0, 
+        self,
+        limit: int = 50,
+        offset: int = 0,
         bounty_type: Optional[str] = None,
         search: Optional[str] = None
     ) -> list[dict[str, Any]]:
@@ -80,3 +80,13 @@ class BaseRepository(ABC):
     async def get_total_bounties(self, bounty_type: Optional[str] = None, search: Optional[str] = None) -> int:
         """Retrieve the total count of bounties, optionally filtered."""
         pass
+
+    @abstractmethod
+    async def get_state(self, key: str) -> Optional[dict[str, Any]]:
+        """Retrieve a specific state entry by key."""
+        pass
+
+    @abstractmethod
+    async def set_state(self, key: str, value: Any) -> None:
+        """Store a specific state entry by key."""
+        pass

decnet/web/db/sqlite/database.py

@@ -1,22 +1,25 @@
-from sqlalchemy.ext.asyncio import create_async_engine, AsyncSession, async_sessionmaker
-from sqlalchemy import create_engine
+from sqlalchemy.ext.asyncio import AsyncEngine, AsyncSession, async_sessionmaker, create_async_engine
+from sqlalchemy import create_engine, Engine
 from sqlmodel import SQLModel
+from typing import AsyncGenerator
 
 # We need both sync and async engines for SQLite
 # Sync for initialization (DDL) and async for standard queries
 
-def get_async_engine(db_path: str):
+def get_async_engine(db_path: str) -> AsyncEngine:
     # If it's a memory URI, don't add the extra slash that turns it into a relative file
     prefix = "sqlite+aiosqlite:///"
-    if db_path.startswith("file:"):
-        prefix = "sqlite+aiosqlite:///"
+    if db_path.startswith(":memory:"):
+        prefix = "sqlite+aiosqlite://"
     return create_async_engine(f"{prefix}{db_path}", echo=False, connect_args={"uri": True})
 
-def get_sync_engine(db_path: str):
+def get_sync_engine(db_path: str) -> Engine:
     prefix = "sqlite:///"
+    if db_path.startswith(":memory:"):
+        prefix = "sqlite://"
     return create_engine(f"{prefix}{db_path}", echo=False, connect_args={"uri": True})
 
-def init_db(db_path: str):
+def init_db(db_path: str) -> None:
     """Synchronously create all tables."""
     engine = get_sync_engine(db_path)
     # Ensure WAL mode is set
@@ -25,7 +28,7 @@ def init_db(db_path: str):
         conn.exec_driver_sql("PRAGMA synchronous=NORMAL")
     SQLModel.metadata.create_all(engine)
 
-async def get_session(engine) -> AsyncSession:
+async def get_session(engine: AsyncEngine) -> AsyncGenerator[AsyncSession, None]:
     async_session = async_sessionmaker(
         engine, class_=AsyncSession, expire_on_commit=False
     )

decnet/web/db/sqlite/repository.py

@@ -6,12 +6,13 @@ from typing import Any, Optional, List
 
 from sqlalchemy import func, select, desc, asc, text, or_, update, literal_column
 from sqlalchemy.ext.asyncio import AsyncSession, async_sessionmaker
+from sqlmodel.sql.expression import SelectOfScalar
 
 from decnet.config import load_state, _ROOT
 from decnet.env import DECNET_ADMIN_USER, DECNET_ADMIN_PASSWORD
 from decnet.web.auth import get_password_hash
 from decnet.web.db.repository import BaseRepository
-from decnet.web.db.models import User, Log, Bounty
+from decnet.web.db.models import User, Log, Bounty, State
 from decnet.web.db.sqlite.database import get_async_engine, init_db
 
 
@@ -93,11 +94,11 @@ class SQLiteRepository(BaseRepository):
 
     def _apply_filters(
         self,
-        statement,
+        statement: SelectOfScalar,
         search: Optional[str],
         start_time: Optional[str],
         end_time: Optional[str],
-    ):
+    ) -> SelectOfScalar:
         import re
         import shlex
 
@@ -128,9 +129,10 @@ class SQLiteRepository(BaseRepository):
                         statement = statement.where(core_fields[key] == val)
                     else:
                         key_safe = re.sub(r"[^a-zA-Z0-9_]", "", key)
-                        statement = statement.where(
-                            text(f"json_extract(fields, '$.{key_safe}') = :val")
-                        ).params(val=val)
+                        if key_safe:
+                            statement = statement.where(
+                                text(f"json_extract(fields, '$.{key_safe}') = :val")
+                            ).params(val=val)
                 else:
                     lk = f"%{token}%"
                     statement = statement.where(
@@ -206,7 +208,7 @@ class SQLiteRepository(BaseRepository):
         end_time: Optional[str] = None,
         interval_minutes: int = 15,
     ) -> List[dict]:
-        bucket_seconds = interval_minutes * 60
+        bucket_seconds = max(interval_minutes, 1) * 60
         bucket_expr = literal_column(
             f"datetime((strftime('%s', timestamp) / {bucket_seconds}) * {bucket_seconds}, 'unixepoch')"
         ).label("bucket_time")
@@ -299,7 +301,12 @@ class SQLiteRepository(BaseRepository):
             session.add(Bounty(**data))
             await session.commit()
 
-    def _apply_bounty_filters(self, statement, bounty_type: Optional[str], search: Optional[str]):
+    def _apply_bounty_filters(
+        self,
+        statement: SelectOfScalar,
+        bounty_type: Optional[str],
+        search: Optional[str]
+    ) -> SelectOfScalar:
         if bounty_type:
             statement = statement.where(Bounty.bounty_type == bounty_type)
         if search:
@@ -350,3 +357,29 @@ class SQLiteRepository(BaseRepository):
         async with self.session_factory() as session:
             result = await session.execute(statement)
             return result.scalar() or 0
+
+    async def get_state(self, key: str) -> Optional[dict[str, Any]]:
+        async with self.session_factory() as session:
+            statement = select(State).where(State.key == key)
+            result = await session.execute(statement)
+            state = result.scalar_one_none()
+            if state:
+                return json.loads(state.value)
+            return None
+
+    async def set_state(self, key: str, value: Any) -> None:  # noqa: ANN401
+        async with self.session_factory() as session:
+            # Check if exists
+            statement = select(State).where(State.key == key)
+            result = await session.execute(statement)
+            state = result.scalar_one_none()
+
+            value_json = json.dumps(value)
+            if state:
+                state.value = value_json
+                session.add(state)
+            else:
+                new_state = State(key=key, value=value_json)
+                session.add(new_state)
+
+            await session.commit()