Switch all db storage to session storage

Only affects CapAdapter, challenge.ts, and redeem.ts.

src/lib/CapAdapter.ts

@@ -1,85 +1,42 @@
 import Cap, { type ChallengeData } from "@cap.js/server";
-import { db, eq, and, gt, lte, Cap_Challenges, Cap_Tokens } from "astro:db";
+import type { AstroSession } from "astro";
 
-const cap = new Cap({
-  storage: {
-    challenges: {
-      store: async (token: string, challengeData: ChallengeData) => {
-        const expires = challengeData.expires;
-        const data = challengeData.challenge;
-        await db
-          .insert(Cap_Challenges)
-          .values({ token: token, data: data, expires: expires })
-          .onConflictDoUpdate({
-            target: Cap_Challenges.token,
-            set: { data: data, expires: expires },
-          });
+export function createCap(session: AstroSession<any> | null) {
+  if (!session) {
+    throw new Error("Session context is required");
+  }
+  return new Cap({
+    storage: {
+      challenges: {
+        store: async (token: string, challengeData: ChallengeData) => {
+          session.set(`cap:challenge:${token}`, JSON.stringify(challengeData));
+        },
+        read: async (token: string) => {
+          const raw = await session.get(`cap:challenge:${token}`);
+          return raw ? (JSON.parse(raw) as ChallengeData) : null;
+        },
+        delete: async (token: string) => {
+          session.delete(`cap:challenge:${token}`);
+        },
+        deleteExpired: async () => {
+          // no-op: session store handles TTL itself
+        },
       },
-      read: async (token) => {
-        const result = await db
-          .select({
-            challenge: Cap_Challenges.data,
-            expires: Cap_Challenges.expires,
-          })
-          .from(Cap_Challenges)
-          .where(
-            and(
-              eq(Cap_Challenges.token, token),
-              gt(Cap_Challenges.expires, Date.now()),
-            ),
-          )
-          .limit(1);
-
-        const data = result[0] as ChallengeData;
-
-        return result ? data : null;
-      },
-
-      delete: async (token) => {
-        await db.delete(Cap_Challenges).where(eq(Cap_Challenges.token, token));
-      },
-
-      deleteExpired: async () => {
-        await db
-          .delete(Cap_Challenges)
-          .where(lte(Cap_Challenges.expires, Date.now()));
+      tokens: {
+        store: async (tokenKey: string, expires: number) => {
+          session.set(`cap:token:${tokenKey}`, String(expires));
+        },
+        get: async (tokenKey: string) => {
+          const raw = await session.get(`cap:token:${tokenKey}`);
+          return raw ? Number(raw) : null;
+        },
+        delete: async (tokenKey: string) => {
+          session.delete(`cap:token:${tokenKey}`);
+        },
+        deleteExpired: async () => {
+          // no-op: session store handles TTL itself
+        },
       },
     },
-    tokens: {
-      store: async (tokenKey, expires) => {
-        await db
-          .insert(Cap_Tokens)
-          .values({ key: tokenKey, expires: expires })
-          .onConflictDoUpdate({
-            target: Cap_Tokens.key,
-            set: { expires: expires },
-          });
-      },
-
-      get: async (tokenKey) => {
-        const result = await db
-          .select({ expires: Cap_Tokens.expires })
-          .from(Cap_Tokens)
-          .where(
-            and(
-              eq(Cap_Tokens.key, tokenKey),
-              gt(Cap_Tokens.expires, Date.now()),
-            ),
-          )
-          .limit(1);
-
-        return result ? result[0].expires : null;
-      },
-
-      delete: async (tokenKey) => {
-        await db.delete(Cap_Tokens).where(eq(Cap_Tokens.key, tokenKey));
-      },
-
-      deleteExpired: async () => {
-        await db.delete(Cap_Tokens).where(lte(Cap_Tokens.expires, Date.now()));
-      },
-    },
-  },
-});
-
-export default cap;
+  });
+}