move kv around

src/atproto/__init__.py

···
 from typing import Any
 import httpx
 
-from ..db import KV
+from .kv import KV, nokv
 
 from .validator import is_valid_authserver_meta
 from ..security import is_safe_url
···
     return regex_match(DID_REGEX, did) is not None
 
 
-def resolve_identity(query: str, didkv: KV) -> tuple[str, str, dict[str, Any]] | None:
+def resolve_identity(
+    query: str,
+    didkv: KV = nokv,
+) -> tuple[str, str, dict[str, Any]] | None:
     """Resolves an identity to a DID, handle and DID document, verifies handles bi directionally."""
 
     if is_valid_handle(query):
-        handle = query
+        handle = query.lower()
         did = resolve_did_from_handle(handle, didkv)
         if not did:
             return None
···
     handles: list[str] = []
     for aka in doc.get("alsoKnownAs", []):
         if aka.startswith("at://"):
-            handle = aka[5:]
+            handle = aka[5:].lower()
             if is_valid_handle(handle):
                 handles.append(handle)
     return handles
···
         return None
 
 
-def resolve_did_from_handle(handle: str, kv: KV, reload: bool = False) -> str | None:
+def resolve_did_from_handle(
+    handle: str,
+    kv: KV = nokv,
+    reload: bool = False,
+) -> str | None:
     """Returns the DID for a given handle"""
 
     if not is_valid_handle(handle):
···
     return None
 
 
-def resolve_pds_from_did(did: DID, kv: KV, reload: bool = False) -> PdsUrl | None:
+def resolve_pds_from_did(
+    did: DID,
+    kv: KV = nokv,
+    reload: bool = False,
+) -> PdsUrl | None:
     pds = kv.get(did)
     if pds is not None and not reload:
         print(f"returning cached pds for {did}")
···
 
 def resolve_authserver_from_pds(
     pds_url: PdsUrl,
-    kv: KV,
+    kv: KV = nokv,
     reload: bool = False,
 ) -> AuthserverUrl | None:
     """Returns the authserver URL for the PDS."""
···
     repo: str,
     collection: str,
     record: str,
+    type: str | None = None,
 ) -> dict[str, Any] | None:
     """Retrieve record from PDS. Verifies type is the same as collection name."""
     response = httpx.get(
···
         return None
     parsed = response.json()
     value: dict[str, Any] = parsed["value"]
-    if value["$type"] != collection:
+    if value["$type"] != (type or collection):
         return None
     del value["$type"]
     return value

src/atproto/kv.py

···
+from abc import ABC, abstractmethod
+from typing import override
+
+
+class KV(ABC):
+    @abstractmethod
+    def get(self, key: str) -> str | None:
+        pass
+
+    @abstractmethod
+    def set(self, key: str, value: str):
+        pass
+
+
+class NoKV(KV):
+    @override
+    def get(self, key: str) -> str | None:
+        return None
+
+    @override
+    def set(self, key: str, value: str):
+        pass
+
+
+nokv = NoKV()

src/db.py

···
-from abc import ABC, abstractmethod
 from typing import override
 from flask import Flask, g
 
 import sqlite3
 from sqlite3 import Connection
 
+from .atproto.kv import KV as BaseKV
 
-class KV(ABC):
-    @abstractmethod
-    def get(self, key: str) -> str | None:
-        pass
 
-    @abstractmethod
-    def set(self, key: str, value: str):
-        pass
-
-
-class Keyval(KV):
+class KV(BaseKV):
     db: Connection
     prefix: str
 
-    def __init__(self, app: Flask, prefix: str):
-        self.db = get_db(app)
+    def __init__(self, app: Connection | Flask, prefix: str):
+        self.db = app if isinstance(app, Connection) else get_db(app)
         self.prefix = prefix
 
     @override

src/main.py

···
     resolve_pds_from_did,
 )
 from .atproto.oauth import pds_authed_req
-from .db import Keyval, close_db_connection, init_db
+from .db import KV, close_db_connection, init_db
 from .oauth import get_auth_session, oauth, save_auth_session
 from .types import OAuthSession
 
···
 @app.get("/@<string:handle>")
 def page_profile_with_handle(handle: str):
     reload = request.args.get("reload") is not None
-    kv = Keyval(app, "did_from_handle")
+    kv = KV(app, "did_from_handle")
     did = resolve_did_from_handle(handle, kv, reload=reload)
     if did is None:
         return "did not found", 404
···
 
 
 def page_profile(did: str, reload: bool = False):
-    kv = Keyval(app, "pds_from_did")
+    kv = KV(app, "pds_from_did")
     pds = resolve_pds_from_did(did, kv, reload=reload)
     if pds is None:
         return "pds not found", 404
···
 
 
 def load_links(pds: str, did: str, reload: bool = False) -> list[dict[str, str]] | None:
-    kv = Keyval(app, "links_from_did")
+    kv = KV(app, "links_from_did")
     links = kv.get(did)
 
     if links is not None and not reload:
···
     did: str,
     reload: bool = False,
 ) -> tuple[tuple[str, str] | None, bool]:
-    kv = Keyval(app, "profile_from_did")
+    kv = KV(app, "profile_from_did")
     profile = kv.get(did)
 
     if profile is not None and not reload:

src/oauth.py

···
 
 import json
 
-from .db import Keyval
+from .db import KV, get_db
 
 from .atproto import (
     is_valid_did,
···
     if not username:
         return redirect(url_for("page_login"), 303)
 
-    pdskv = Keyval(current_app, "authserver_from_pds")
+    db = get_db(current_app)
+    pdskv = KV(db, "authserver_from_pds")
 
     if is_valid_handle(username) or is_valid_did(username):
         login_hint = username
-        kv = Keyval(current_app, "did_from_handle")
+        kv = KV(db, "did_from_handle")
         identity = resolve_identity(username, didkv=kv)
         if identity is None:
             return "couldnt resolve identity", 500
···
 
     row = auth_request
 
-    didkv = Keyval(current_app, "did_from_handle")
-    authserverkv = Keyval(current_app, "authserver_from_pds")
+    db = get_db(current_app)
+    didkv = KV(db, "did_from_handle")
+    authserverkv = KV(db, "authserver_from_pds")
 
     if row.did:
         # If we started with an account identifier, this is simple

src/schema.sql

···
-drop table if exists keyval;
 create table if not exists keyval (
     prefix text not null,
     key text not null,

src/templates/login.html

···
       <form action="{{ url_for('auth_login') }}" method="post">
         <label>
           <span>Handle</span>
-          <input type="text" name="username" placeholder="username.example.com" required />
+          <input type="text" name="username" placeholder="username.example.com" autocapitalize="off" autocomplete="off" spellcheck="false" required />
         </label>
         <span class="caption">
           Use your AT Protocol handle to log in.