add experimental valtown sqlite session/oauth adapters

packages/oauth/deno.json

···
 {
   "name": "@slices/oauth",
-  "version": "0.6.0",
+  "version": "0.7.0-alpha.4",
   "exports": {
     ".": "./mod.ts"
+  },
+  "imports": {
+    "@libsql/client": "npm:@libsql/client@0.6.0"
   },
   "compilerOptions": {
     "lib": ["deno.ns", "deno.unstable", "dom", "dom.iterable", "esnext"]

packages/oauth/mod.ts

···
 export { DeviceFlowClient } from "./src/device.ts";
 export { DenoKVOAuthStorage } from "./src/storage/deno-kv.ts";
 export { SQLiteOAuthStorage } from "./src/storage/sqlite.ts";
+export { ValTownSQLiteOAuthStorage } from "./src/storage/valtown-sqlite.ts";
 export type {
   OAuthConfig,
   OAuthTokens,

packages/oauth/src/storage/valtown-sqlite.ts

···
+import type { OAuthStorage, OAuthTokens } from "../types.ts";
+import type { InStatement, TransactionMode } from "@libsql/client";
+
+// Val Town's SQLite ResultSet (doesn't have toJSON method)
+interface ValTownResultSet {
+  columns: string[];
+  columnTypes: string[];
+  rows: unknown[][];
+  rowsAffected: number;
+  lastInsertRowid?: bigint;
+}
+
+interface SQLiteInstance {
+  execute(statement: InStatement): Promise<ValTownResultSet>;
+  batch(
+    statements: InStatement[],
+    mode?: TransactionMode,
+  ): Promise<ValTownResultSet[]>;
+}
+
+export class ValTownSQLiteOAuthStorage implements OAuthStorage {
+  private sqlite: SQLiteInstance;
+
+  constructor(sqlite: SQLiteInstance) {
+    this.sqlite = sqlite;
+    this.initTables();
+  }
+
+  private async initTables(): Promise<void> {
+    // Create tokens table
+    await this.sqlite.execute(`
+      CREATE TABLE IF NOT EXISTS oauth_tokens (
+        id INTEGER PRIMARY KEY,
+        session_id TEXT,
+        access_token TEXT NOT NULL,
+        token_type TEXT NOT NULL,
+        expires_at INTEGER,
+        refresh_token TEXT,
+        scope TEXT,
+        created_at INTEGER NOT NULL DEFAULT (strftime('%s', 'now') * 1000),
+        UNIQUE(session_id)
+      )
+    `);
+
+    // Create states table with automatic cleanup
+    await this.sqlite.execute(`
+      CREATE TABLE IF NOT EXISTS oauth_states (
+        state TEXT PRIMARY KEY,
+        code_verifier TEXT NOT NULL,
+        timestamp INTEGER NOT NULL DEFAULT (strftime('%s', 'now') * 1000)
+      )
+    `);
+
+    // Create index for cleanup efficiency
+    await this.sqlite.execute(`
+      CREATE INDEX IF NOT EXISTS idx_oauth_states_timestamp ON oauth_states(timestamp)
+    `);
+  }
+
+  async getTokens(sessionId: string): Promise<OAuthTokens | null> {
+    const result = await this.sqlite.execute({
+      sql: `SELECT access_token, token_type, expires_at, refresh_token, scope
+            FROM oauth_tokens
+            WHERE session_id = ?
+            LIMIT 1`,
+      args: [sessionId],
+    });
+
+    if (result.rows.length === 0) return null;
+
+    const row = result.rows[0];
+
+    return {
+      accessToken: row[0] as string,
+      tokenType: row[1] as string,
+      expiresAt: (row[2] as number | null) ?? undefined,
+      refreshToken: (row[3] as string | null) ?? undefined,
+      scope: (row[4] as string | null) ?? undefined,
+    };
+  }
+
+  async setTokens(tokens: OAuthTokens, sessionId: string): Promise<void> {
+    await this.clearTokens(sessionId);
+
+    await this.sqlite.execute({
+      sql:
+        `INSERT INTO oauth_tokens (session_id, access_token, token_type, expires_at, refresh_token, scope)
+            VALUES (?, ?, ?, ?, ?, ?)`,
+      args: [
+        sessionId,
+        tokens.accessToken,
+        tokens.tokenType,
+        tokens.expiresAt ?? null,
+        tokens.refreshToken ?? null,
+        tokens.scope ?? null,
+      ],
+    });
+  }
+
+  async clearTokens(sessionId: string): Promise<void> {
+    await this.sqlite.execute({
+      sql: "DELETE FROM oauth_tokens WHERE session_id = ?",
+      args: [sessionId],
+    });
+  }
+
+  async getState(state: string): Promise<string | null> {
+    const result = await this.sqlite.execute({
+      sql: "SELECT code_verifier FROM oauth_states WHERE state = ?",
+      args: [state],
+    });
+
+    if (result.rows.length === 0) return null;
+
+    const codeVerifier = result.rows[0][0] as string;
+
+    // Delete after use (one-time use)
+    await this.clearState(state);
+
+    return codeVerifier;
+  }
+
+  async setState(state: string, codeVerifier: string): Promise<void> {
+    await this.sqlite.execute({
+      sql:
+        `INSERT OR REPLACE INTO oauth_states (state, code_verifier, timestamp)
+            VALUES (?, ?, ?)`,
+      args: [state, codeVerifier, Date.now()],
+    });
+
+    // Auto-cleanup expired states
+    await this.cleanup();
+  }
+
+  async clearState(state: string): Promise<void> {
+    await this.sqlite.execute({
+      sql: "DELETE FROM oauth_states WHERE state = ?",
+      args: [state],
+    });
+  }
+
+  private async cleanup(): Promise<void> {
+    const cutoff = Date.now() - (10 * 60 * 1000); // 10 minutes ago
+    await this.sqlite.execute({
+      sql: "DELETE FROM oauth_states WHERE timestamp < ?",
+      args: [cutoff],
+    });
+  }
+}

packages/session/deno.json

···
 {
   "name": "@slices/session",
-  "version": "0.3.0",
+  "version": "0.4.0-alpha.4",
   "exports": "./mod.ts",
   "compilerOptions": {
     "lib": ["deno.ns", "deno.unstable", "esnext", "dom"]
···
     "check": "deno check mod.ts"
   },
   "imports": {
-    "pg": "npm:pg@^8.16.3"
+    "pg": "npm:pg@^8.16.3",
+    "@libsql/client": "npm:@libsql/client@0.6.0"
   }
 }

packages/session/mod.ts

···
 export { SessionStore } from "./src/store.ts";
 export { MemoryAdapter } from "./src/adapters/memory.ts";
 export { SQLiteAdapter } from "./src/adapters/sqlite.ts";
+export { ValTownSQLiteAdapter } from "./src/adapters/valtown-sqlite.ts";
 export { PostgresAdapter } from "./src/adapters/postgres.ts";
 export { DenoKVAdapter } from "./src/adapters/deno-kv.ts";
 export { withOAuthSession } from "./src/oauth-integration.ts";

packages/session/src/adapters/valtown-sqlite.ts

···
+import type { SessionAdapter, SessionData } from "../types.ts";
+import type { InStatement, InValue, TransactionMode } from "@libsql/client";
+
+// Val Town's SQLite ResultSet (doesn't have toJSON method)
+interface ValTownResultSet {
+  columns: string[];
+  columnTypes: string[];
+  rows: unknown[][];
+  rowsAffected: number;
+  lastInsertRowid?: bigint;
+}
+
+interface SQLiteInstance {
+  execute(statement: InStatement): Promise<ValTownResultSet>;
+  batch(statements: InStatement[], mode?: TransactionMode): Promise<ValTownResultSet[]>;
+}
+
+export class ValTownSQLiteAdapter implements SessionAdapter {
+  private sqlite: SQLiteInstance;
+
+  constructor(sqlite: SQLiteInstance) {
+    this.sqlite = sqlite;
+    this.initializeDatabase();
+  }
+
+  private async initializeDatabase(): Promise<void> {
+    await this.sqlite.execute(`
+      CREATE TABLE IF NOT EXISTS sessions (
+        session_id TEXT PRIMARY KEY,
+        user_id TEXT NOT NULL,
+        handle TEXT,
+        is_authenticated INTEGER NOT NULL DEFAULT 1,
+        data TEXT, -- JSON string
+        created_at INTEGER NOT NULL,
+        expires_at INTEGER NOT NULL,
+        last_accessed_at INTEGER NOT NULL
+      )
+    `);
+
+    // Index for cleanup operations
+    await this.sqlite.execute(`
+      CREATE INDEX IF NOT EXISTS idx_sessions_expires_at
+      ON sessions(expires_at)
+    `);
+
+    // Index for user lookups
+    await this.sqlite.execute(`
+      CREATE INDEX IF NOT EXISTS idx_sessions_user_id
+      ON sessions(user_id)
+    `);
+  }
+
+  async get(sessionId: string): Promise<SessionData | null> {
+    const result = await this.sqlite.execute({
+      sql: `SELECT session_id, user_id, handle, is_authenticated, data, created_at, expires_at, last_accessed_at
+            FROM sessions
+            WHERE session_id = ?`,
+      args: [sessionId]
+    });
+
+    if (result.rows.length === 0) return null;
+
+    return this.rowToSessionData(result.rows[0]);
+  }
+
+  async set(sessionId: string, data: SessionData): Promise<void> {
+    await this.sqlite.execute({
+      sql: `INSERT OR REPLACE INTO sessions
+            (session_id, user_id, handle, is_authenticated, data, created_at, expires_at, last_accessed_at)
+            VALUES (?, ?, ?, ?, ?, ?, ?, ?)`,
+      args: [
+        sessionId,
+        data.userId,
+        data.handle ?? null,
+        data.isAuthenticated ? 1 : 0,
+        data.data ? JSON.stringify(data.data) : null,
+        data.createdAt,
+        data.expiresAt,
+        data.lastAccessedAt,
+      ]
+    });
+  }
+
+  async update(sessionId: string, updates: Partial<SessionData>): Promise<boolean> {
+    const setParts: string[] = [];
+    const values: InValue[] = [];
+
+    if (updates.userId !== undefined) {
+      setParts.push("user_id = ?");
+      values.push(updates.userId);
+    }
+
+    if (updates.handle !== undefined) {
+      setParts.push("handle = ?");
+      values.push(updates.handle ?? null);
+    }
+
+    if (updates.isAuthenticated !== undefined) {
+      setParts.push("is_authenticated = ?");
+      values.push(updates.isAuthenticated ? 1 : 0);
+    }
+
+    if (updates.data !== undefined) {
+      setParts.push("data = ?");
+      values.push(updates.data ? JSON.stringify(updates.data) : null);
+    }
+
+    if (updates.expiresAt !== undefined) {
+      setParts.push("expires_at = ?");
+      values.push(updates.expiresAt);
+    }
+
+    if (updates.lastAccessedAt !== undefined) {
+      setParts.push("last_accessed_at = ?");
+      values.push(updates.lastAccessedAt);
+    }
+
+    if (setParts.length === 0) return false;
+
+    // Add sessionId as the last parameter for WHERE clause
+    values.push(sessionId);
+
+    const result = await this.sqlite.execute({
+      sql: `UPDATE sessions
+            SET ${setParts.join(", ")}
+            WHERE session_id = ?`,
+      args: values
+    });
+
+    return result.rowsAffected > 0;
+  }
+
+  async delete(sessionId: string): Promise<void> {
+    await this.sqlite.execute({
+      sql: "DELETE FROM sessions WHERE session_id = ?",
+      args: [sessionId]
+    });
+  }
+
+  async cleanup(expiresBeforeMs: number): Promise<number> {
+    const result = await this.sqlite.execute({
+      sql: "DELETE FROM sessions WHERE expires_at < ?",
+      args: [expiresBeforeMs]
+    });
+    return result.rowsAffected;
+  }
+
+  async exists(sessionId: string): Promise<boolean> {
+    const result = await this.sqlite.execute({
+      sql: "SELECT 1 FROM sessions WHERE session_id = ? LIMIT 1",
+      args: [sessionId]
+    });
+    return result.rows.length > 0;
+  }
+
+  private rowToSessionData(row: unknown[]): SessionData {
+    return {
+      sessionId: row[0] as string,
+      userId: row[1] as string,
+      handle: (row[2] as string | null) ?? undefined,
+      isAuthenticated: Boolean(row[3] as number),
+      data: row[4] ? JSON.parse(row[4] as string) : undefined,
+      createdAt: row[5] as number,
+      expiresAt: row[6] as number,
+      lastAccessedAt: row[7] as number,
+    };
+  }
+
+  // Val Town SQLite-specific methods
+  async getSessionsByUser(userId: string): Promise<SessionData[]> {
+    const result = await this.sqlite.execute({
+      sql: `SELECT session_id, user_id, handle, is_authenticated, data, created_at, expires_at, last_accessed_at
+            FROM sessions
+            WHERE user_id = ?`,
+      args: [userId]
+    });
+
+    return result.rows.map(row => this.rowToSessionData(row));
+  }
+}