extend Storage Protocol to cover all SqliteStorage methods

Author: sujalgoel

src/ghdcbot/core/interfaces.py

@@ -1,8 +1,9 @@
 from __future__ import annotations
 
 from datetime import datetime
-from typing import Iterable, Protocol, Sequence
+from typing import Any, Iterable, Protocol, Sequence
 
+from ghdcbot.config.models import IdentityMapping
 from ghdcbot.core.models import (
     AssignmentPlan,
     ContributionEvent,
@@ -59,6 +60,7 @@ def list_contribution_summaries(
         period_start: datetime,
         period_end: datetime,
         weights: dict[str, int],
+        difficulty_weights: dict[str, int] | None = None,
     ) -> Sequence[ContributionSummary]:
         """Aggregate contribution counts and scores for the period."""
 
@@ -74,6 +76,88 @@ def get_cursor(self, source: str) -> datetime | None:
     def set_cursor(self, source: str, cursor: datetime) -> None:
         """Persist last sync cursor for a source."""
 
+    # Identity linking
+
+    def create_identity_claim(
+        self,
+        discord_user_id: str,
+        github_user: str,
+        verification_code: str,
+        expires_at: datetime,
+        *,
+        max_age_days: int | None = None,
+    ) -> None:
+        """Create or refresh a pending identity claim for (discord_user_id, github_user)."""
+
+    def get_identity_link(self, discord_user_id: str, github_user: str) -> dict | None:
+        """Return identity link row for (discord_user_id, github_user), or None."""
+
+    def mark_identity_verified(self, discord_user_id: str, github_user: str) -> None:
+        """Mark an identity claim as verified."""
+
+    def unlink_identity(self, discord_user_id: str, cooldown_hours: int) -> dict | None:
+        """Unlink the verified identity for a Discord user. Returns unlink info or None."""
+
+    def list_verified_identity_mappings(self) -> list[IdentityMapping]:
+        """Return all verified identity mappings."""
+
+    def get_identity_links_for_discord_user(self, discord_user_id: str) -> list[dict]:
+        """Return all identity link rows for a Discord user (verified and pending)."""
+
+    def get_identity_status(
+        self, discord_user_id: str, max_age_days: int | None = None
+    ) -> dict:
+        """Return current identity status dict for a Discord user."""
+
+    # Issue requests
+
+    def insert_issue_request(
+        self,
+        request_id: str,
+        discord_user_id: str,
+        github_user: str,
+        owner: str,
+        repo: str,
+        issue_number: int,
+        issue_url: str,
+    ) -> None:
+        """Store a new issue assignment request with status pending."""
+
+    def list_pending_issue_requests(self) -> list[dict]:
+        """Return all pending issue requests ordered by created_at ascending."""
+
+    def get_issue_request(self, request_id: str) -> dict | None:
+        """Return a single issue request by request_id, or None."""
+
+    def update_issue_request_status(self, request_id: str, status: str) -> None:
+        """Update an issue request status (pending, approved, rejected, cancelled)."""
+
+    # Audit log
+
+    def append_audit_event(self, event: dict) -> None:
+        """Append an audit event (append-only)."""
+
+    def list_audit_events(self) -> list[dict]:
+        """Return all audit events."""
+
+    # Notifications
+
+    def was_notification_sent(self, dedupe_key: str) -> bool:
+        """Check if a notification was already sent (deduplication)."""
+
+    def mark_notification_sent(
+        self,
+        dedupe_key: str,
+        event: Any,
+        discord_user_id: str,
+        channel_id: str | None,
+        target_github_user: str | None = None,
+    ) -> None:
+        """Record that a notification was sent (deduplication tracking)."""
+
+    def list_recent_notifications(self, limit: int = 1000) -> list[dict]:
+        """Return recent sent notifications ordered by sent_at descending."""
+
 
 class ScoreStrategy(Protocol):
     def compute_scores(

src/ghdcbot/engine/snapshots.py

@@ -21,6 +21,7 @@
 from typing import Any
 
 from ghdcbot.config.models import BotConfig, IdentityMapping
+from ghdcbot.core.interfaces import Storage
 from ghdcbot.core.models import ContributionEvent, ContributionSummary, Score
 
 logger = logging.getLogger("Snapshots")
@@ -30,7 +31,7 @@
 
 
 def write_snapshots_to_github(
-    storage: Any,
+    storage: Storage,
     config: BotConfig,
     github_writer: Any,
     identity_mappings: list[IdentityMapping],
@@ -83,7 +84,7 @@ def write_snapshots_to_github(
 
 
 def _write_snapshots(
-    storage: Any,
+    storage: Storage,
     config: BotConfig,
     github_writer: Any,
     snapshot_config: Any,
@@ -138,23 +139,21 @@ def _write_snapshots(
             },
         )
         # Audit log
-        append_audit = getattr(storage, "append_audit_event", None)
-        if callable(append_audit):
-            append_audit({
-                "event_type": "snapshot_written",
-                "context": {
-                    "org": config.github.org,
-                    "repo": f"{owner}/{repo}",
-                    "snapshot_dir": snapshot_dir,
-                    "run_id": run_id,
-                    "files_written": files_written,
-                    "timestamp": now.isoformat(),
-                },
-            })
+        storage.append_audit_event({
+            "event_type": "snapshot_written",
+            "context": {
+                "org": config.github.org,
+                "repo": f"{owner}/{repo}",
+                "snapshot_dir": snapshot_dir,
+                "run_id": run_id,
+                "files_written": files_written,
+                "timestamp": now.isoformat(),
+            },
+        })
 
 
 def _collect_snapshot_data(
-    storage: Any,
+    storage: Storage,
     config: BotConfig,
     identity_mappings: list[IdentityMapping],
     scores: list[Score],
@@ -253,21 +252,19 @@ def _collect_snapshot_data(
 
     # Issue requests snapshot
     issue_requests_data = []
-    list_pending = getattr(storage, "list_pending_issue_requests", None)
-    if callable(list_pending):
-        pending_requests = list_pending()
-        for req in pending_requests:
-            issue_requests_data.append({
-                "request_id": req.get("request_id"),
-                "discord_user_id": req.get("discord_user_id"),
-                "github_user": req.get("github_user"),
-                "owner": req.get("owner"),
-                "repo": req.get("repo"),
-                "issue_number": req.get("issue_number"),
-                "issue_url": req.get("issue_url"),
-                "created_at": req.get("created_at"),
-                "status": req.get("status"),
-            })
+    pending_requests = storage.list_pending_issue_requests()
+    for req in pending_requests:
+        issue_requests_data.append({
+            "request_id": req.get("request_id"),
+            "discord_user_id": req.get("discord_user_id"),
+            "github_user": req.get("github_user"),
+            "owner": req.get("owner"),
+            "repo": req.get("repo"),
+            "issue_number": req.get("issue_number"),
+            "issue_url": req.get("issue_url"),
+            "created_at": req.get("created_at"),
+            "status": req.get("status"),
+        })
 
     issue_requests = {
         "schema_version": SCHEMA_VERSION,
@@ -279,20 +276,18 @@ def _collect_snapshot_data(
 
     # Notifications snapshot (recent sent notifications)
     notifications_data = []
-    list_notifications = getattr(storage, "list_recent_notifications", None)
-    if callable(list_notifications):
-        recent_notifications = list_notifications(limit=1000)  # Last 1000 notifications
-        for notif in recent_notifications:
-            notifications_data.append({
-                "dedupe_key": notif.get("dedupe_key"),
-                "event_type": notif.get("event_type"),
-                "github_user": notif.get("github_user"),
-                "discord_user_id": notif.get("discord_user_id"),
-                "repo": notif.get("repo"),
-                "target": notif.get("target"),
-                "channel_id": notif.get("channel_id"),
-                "sent_at": notif.get("sent_at"),
-            })
+    recent_notifications = storage.list_recent_notifications(limit=1000)
+    for notif in recent_notifications:
+        notifications_data.append({
+            "dedupe_key": notif.get("dedupe_key"),
+            "event_type": notif.get("event_type"),
+            "github_user": notif.get("github_user"),
+            "discord_user_id": notif.get("discord_user_id"),
+            "repo": notif.get("repo"),
+            "target": notif.get("target"),
+            "channel_id": notif.get("channel_id"),
+            "sent_at": notif.get("sent_at"),
+        })
 
     notifications = {
         "schema_version": SCHEMA_VERSION,