Initial release v0.1.0

Framework-agnostic storage implementations for AT Protocol OAuth:
- OAuthStorage interface with TTL support
- MemoryStorage for testing/development
- SQLiteStorage with adapter pattern for any SQLite driver
- Pre-built adapters: valTownAdapter, denoSqliteAdapter, betterSqlite3Adapter

.gitignore

···
+# IDE
+.idea/
+.vscode/
+*.swp
+*.swo
+
+# OS
+.DS_Store
+Thumbs.db
+
+# Coverage
+coverage/

CHANGELOG.md

···
+# Changelog
+
+All notable changes to this project will be documented in this file.
+
+## [0.1.0] - 2025-11-27
+
+### Added
+
+- Initial release
+- `OAuthStorage` interface for key-value storage with TTL support
+- `MemoryStorage` implementation for testing and development
+- `SQLiteStorage` implementation for production use
+- Adapter pattern for SQLite backends:
+  - `valTownAdapter()` for Val.Town sqlite and libSQL/Turso
+  - `denoSqliteAdapter()` for @db/sqlite (Deno native)
+  - `betterSqlite3Adapter()` for better-sqlite3 (Node.js)
+- Automatic table creation and schema management
+- TTL-based expiration with cleanup method
+- Comprehensive test suite

LICENSE

···
+MIT License
+
+Copyright (c) 2025 Tijs Teulings
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

README.md

···
+# @tijs/atproto-storage
+
+Storage implementations for AT Protocol OAuth applications. Provides a simple
+key-value storage interface with implementations for in-memory and SQLite
+backends.
+
+## Installation
+
+```typescript
+import {
+  MemoryStorage,
+  SQLiteStorage,
+  valTownAdapter,
+} from "jsr:@tijs/atproto-storage";
+```
+
+## Usage
+
+### In-Memory Storage (Testing/Development)
+
+```typescript
+import { MemoryStorage } from "jsr:@tijs/atproto-storage";
+
+const storage = new MemoryStorage();
+
+// Store with TTL (seconds)
+await storage.set("session:123", { did: "did:plc:abc" }, { ttl: 3600 });
+
+// Retrieve
+const session = await storage.get("session:123");
+
+// Delete
+await storage.delete("session:123");
+```
+
+### SQLite Storage (Production)
+
+SQLiteStorage works with any SQLite driver via adapters:
+
+#### Val.Town / libSQL / Turso
+
+```typescript
+import { sqlite } from "https://esm.town/v/std/sqlite";
+import { SQLiteStorage, valTownAdapter } from "jsr:@tijs/atproto-storage";
+
+const storage = new SQLiteStorage(valTownAdapter(sqlite));
+```
+
+#### Deno Native SQLite
+
+```typescript
+import { Database } from "jsr:@db/sqlite";
+import { denoSqliteAdapter, SQLiteStorage } from "jsr:@tijs/atproto-storage";
+
+const db = new Database("storage.db");
+const storage = new SQLiteStorage(denoSqliteAdapter(db));
+```
+
+#### better-sqlite3 (Node.js)
+
+```typescript
+import Database from "better-sqlite3";
+import { betterSqlite3Adapter, SQLiteStorage } from "jsr:@tijs/atproto-storage";
+
+const db = new Database("storage.db");
+const storage = new SQLiteStorage(betterSqlite3Adapter(db));
+```
+
+#### Custom Adapter
+
+```typescript
+import { SQLiteAdapter, SQLiteStorage } from "jsr:@tijs/atproto-storage";
+
+const customAdapter: SQLiteAdapter = {
+  execute: async (sql, params) => {
+    const result = await myDriver.query(sql, params);
+    return result.rows;
+  },
+};
+
+const storage = new SQLiteStorage(customAdapter);
+```
+
+### Options
+
+```typescript
+const storage = new SQLiteStorage(adapter, {
+  tableName: "my_storage", // Default: "oauth_storage"
+  logger: console, // Optional logger for debugging
+});
+```
+
+### Cleanup
+
+For SQLite storage, periodically clean up expired entries:
+
+```typescript
+const deletedCount = await storage.cleanup();
+```
+
+## API
+
+### OAuthStorage Interface
+
+```typescript
+interface OAuthStorage {
+  get<T = unknown>(key: string): Promise<T | null>;
+  set<T = unknown>(key: string, value: T, options?: { ttl?: number }): Promise<void>;
+  delete(key: string): Promise<void>;
+}
+```
+
+### SQLiteAdapter Interface
+
+```typescript
+interface SQLiteAdapter {
+  execute(sql: string, params: unknown[]): Promise<unknown[][]>;
+}
+```
+
+## License
+
+MIT

deno.json

···
+{
+  "$schema": "https://jsr.io/schema/config-file.v1.json",
+  "name": "@tijs/atproto-storage",
+  "version": "0.1.0",
+  "license": "MIT",
+  "exports": "./mod.ts",
+  "publish": {
+    "include": ["mod.ts", "src/**/*.ts", "README.md", "LICENSE"],
+    "exclude": ["**/*.test.ts"]
+  },
+  "imports": {
+    "@std/assert": "jsr:@std/assert@1.0.16"
+  },
+  "compilerOptions": {
+    "strict": true,
+    "noImplicitAny": true
+  },
+  "tasks": {
+    "test": "deno test --allow-all src/",
+    "check": "deno check mod.ts",
+    "fmt": "deno fmt",
+    "lint": "deno lint",
+    "quality": "deno fmt && deno lint && deno check mod.ts",
+    "ci": "deno task quality && deno task test"
+  }
+}

deno.lock

···
+{
+  "version": "5",
+  "specifiers": {
+    "jsr:@std/assert@1.0.16": "1.0.16",
+    "jsr:@std/internal@^1.0.12": "1.0.12"
+  },
+  "jsr": {
+    "@std/assert@1.0.16": {
+      "integrity": "6a7272ed1eaa77defe76e5ff63ca705d9c495077e2d5fd0126d2b53fc5bd6532",
+      "dependencies": [
+        "jsr:@std/internal"
+      ]
+    },
+    "@std/internal@1.0.12": {
+      "integrity": "972a634fd5bc34b242024402972cd5143eac68d8dffaca5eaa4dba30ce17b027"
+    }
+  },
+  "workspace": {
+    "dependencies": [
+      "jsr:@std/assert@1.0.16"
+    ]
+  }
+}

mod.ts

···
+/**
+ * @module atproto-storage
+ *
+ * Storage implementations for AT Protocol OAuth applications.
+ *
+ * Provides a simple storage interface with implementations for:
+ * - In-memory storage (for testing/development)
+ * - SQLite storage (works with any SQLite driver via adapters)
+ *
+ * @example Val.Town / libSQL
+ * ```typescript
+ * import { sqlite } from "https://esm.town/v/std/sqlite";
+ * import { SQLiteStorage, valTownAdapter } from "@tijs/atproto-storage";
+ *
+ * const storage = new SQLiteStorage(valTownAdapter(sqlite));
+ * ```
+ *
+ * @example Deno native SQLite
+ * ```typescript
+ * import { Database } from "jsr:@db/sqlite";
+ * import { SQLiteStorage, denoSqliteAdapter } from "@tijs/atproto-storage";
+ *
+ * const db = new Database("storage.db");
+ * const storage = new SQLiteStorage(denoSqliteAdapter(db));
+ * ```
+ *
+ * @example Testing with MemoryStorage
+ * ```typescript
+ * import { MemoryStorage } from "@tijs/atproto-storage";
+ *
+ * const storage = new MemoryStorage();
+ * ```
+ *
+ * @example Custom SQLite adapter
+ * ```typescript
+ * import { SQLiteStorage, SQLiteAdapter } from "@tijs/atproto-storage";
+ *
+ * const customAdapter: SQLiteAdapter = {
+ *   execute: async (sql, params) => myDriver.query(sql, params)
+ * };
+ * const storage = new SQLiteStorage(customAdapter);
+ * ```
+ */
+
+// Types
+export type { Logger, OAuthStorage, SQLiteAdapter } from "./src/types.ts";
+
+// Implementations
+export { MemoryStorage } from "./src/memory.ts";
+export { SQLiteStorage } from "./src/sqlite.ts";
+export type { SQLiteStorageOptions } from "./src/sqlite.ts";
+
+// Adapters
+export {
+  betterSqlite3Adapter,
+  denoSqliteAdapter,
+  valTownAdapter,
+} from "./src/adapters.ts";
+export type { ExecutableDriver, PrepareDriver } from "./src/adapters.ts";

src/adapters.ts

···
+/**
+ * Pre-built adapters for common SQLite drivers.
+ * Each adapter converts a specific driver's API to the SQLiteAdapter interface.
+ */
+
+import type { SQLiteAdapter } from "./types.ts";
+
+/**
+ * Driver interface for Val.Town sqlite and libSQL/Turso client.
+ * Both use the same execute({ sql, args }) pattern.
+ */
+export interface ExecutableDriver {
+  execute(
+    query: { sql: string; args: unknown[] },
+  ): Promise<{ rows: unknown[][] }>;
+}
+
+/**
+ * Driver interface for @db/sqlite (Deno native) and similar prepare-based drivers.
+ */
+export interface PrepareDriver {
+  prepare(sql: string): {
+    all<T = Record<string, unknown>>(...params: unknown[]): T[];
+  };
+}
+
+/**
+ * Adapter for Val.Town sqlite and libSQL/Turso client.
+ * These drivers share the same execute({ sql, args }) API pattern.
+ *
+ * @example Val.Town
+ * ```typescript
+ * import { sqlite } from "https://esm.town/v/std/sqlite";
+ * import { SQLiteStorage, valTownAdapter } from "@tijs/atproto-storage";
+ *
+ * const storage = new SQLiteStorage(valTownAdapter(sqlite));
+ * ```
+ *
+ * @example libSQL/Turso
+ * ```typescript
+ * import { createClient } from "@libsql/client";
+ * import { SQLiteStorage, valTownAdapter } from "@tijs/atproto-storage";
+ *
+ * const client = createClient({ url: "libsql://..." });
+ * const storage = new SQLiteStorage(valTownAdapter(client));
+ * ```
+ */
+export function valTownAdapter(driver: ExecutableDriver): SQLiteAdapter {
+  return {
+    execute: async (sql: string, params: unknown[]): Promise<unknown[][]> => {
+      const result = await driver.execute({ sql, args: params });
+      return result.rows;
+    },
+  };
+}
+
+/**
+ * Adapter for @db/sqlite (Deno native SQLite).
+ * Converts the synchronous prepare/all pattern to the async adapter interface.
+ *
+ * @example
+ * ```typescript
+ * import { Database } from "jsr:@db/sqlite";
+ * import { SQLiteStorage, denoSqliteAdapter } from "@tijs/atproto-storage";
+ *
+ * const db = new Database("storage.db");
+ * const storage = new SQLiteStorage(denoSqliteAdapter(db));
+ * ```
+ */
+export function denoSqliteAdapter(db: PrepareDriver): SQLiteAdapter {
+  return {
+    execute: (sql: string, params: unknown[]): Promise<unknown[][]> => {
+      const stmt = db.prepare(sql);
+      const rows = stmt.all(...params);
+      // Convert object rows to array rows (column order from Object.values)
+      return Promise.resolve(
+        rows.map((row) => Object.values(row as Record<string, unknown>)),
+      );
+    },
+  };
+}
+
+/**
+ * Adapter for better-sqlite3 (Node.js).
+ * Same pattern as Deno native but for Node environment.
+ *
+ * @example
+ * ```typescript
+ * import Database from "better-sqlite3";
+ * import { SQLiteStorage, betterSqlite3Adapter } from "@tijs/atproto-storage";
+ *
+ * const db = new Database("storage.db");
+ * const storage = new SQLiteStorage(betterSqlite3Adapter(db));
+ * ```
+ */
+export function betterSqlite3Adapter(db: PrepareDriver): SQLiteAdapter {
+  return {
+    execute: (sql: string, params: unknown[]): Promise<unknown[][]> => {
+      const stmt = db.prepare(sql);
+      const rows = stmt.all(...params);
+      return Promise.resolve(
+        rows.map((row) => Object.values(row as Record<string, unknown>)),
+      );
+    },
+  };
+}

src/memory.ts

···
+/**
+ * In-memory storage implementation for OAuth sessions.
+ * Perfect for testing and development.
+ */
+
+import type { OAuthStorage } from "./types.ts";
+
+interface StorageEntry {
+  value: unknown;
+  expiresAt?: number;
+}
+
+/**
+ * In-memory storage for OAuth sessions and tokens.
+ *
+ * Features:
+ * - Automatic TTL expiration
+ * - No external dependencies
+ * - Perfect for testing and single-process deployments
+ *
+ * Note: Data is lost when the process restarts.
+ * For production, use SQLiteStorage or another persistent implementation.
+ *
+ * @example
+ * ```typescript
+ * const storage = new MemoryStorage();
+ *
+ * // Store with TTL
+ * await storage.set("session:123", { did: "did:plc:abc" }, { ttl: 3600 });
+ *
+ * // Retrieve
+ * const session = await storage.get("session:123");
+ *
+ * // Delete
+ * await storage.delete("session:123");
+ * ```
+ */
+export class MemoryStorage implements OAuthStorage {
+  private data = new Map<string, StorageEntry>();
+
+  get<T = unknown>(key: string): Promise<T | null> {
+    const item = this.data.get(key);
+    if (!item) return Promise.resolve(null);
+
+    // Check expiration
+    if (item.expiresAt && item.expiresAt <= Date.now()) {
+      this.data.delete(key);
+      return Promise.resolve(null);
+    }
+
+    return Promise.resolve(item.value as T);
+  }
+
+  set<T = unknown>(
+    key: string,
+    value: T,
+    options?: { ttl?: number },
+  ): Promise<void> {
+    const expiresAt = options?.ttl
+      ? Date.now() + (options.ttl * 1000)
+      : undefined;
+
+    this.data.set(key, { value, expiresAt });
+    return Promise.resolve();
+  }
+
+  delete(key: string): Promise<void> {
+    this.data.delete(key);
+    return Promise.resolve();
+  }
+
+  /**
+   * Clear all entries from storage.
+   * Useful for testing.
+   */
+  clear(): void {
+    this.data.clear();
+  }
+
+  /**
+   * Get the number of entries in storage.
+   * Useful for testing.
+   */
+  get size(): number {
+    return this.data.size;
+  }
+}

src/sqlite.ts

···
+/**
+ * SQLite storage implementation for OAuth sessions.
+ * Works with any SQLite driver via adapters.
+ */
+
+import type { Logger, OAuthStorage, SQLiteAdapter } from "./types.ts";
+
+/** No-op logger for production use */
+const noopLogger: Logger = {
+  log: () => {},
+  warn: () => {},
+  error: () => {},
+};
+
+/**
+ * Configuration options for SQLiteStorage
+ */
+export interface SQLiteStorageOptions {
+  /** Custom table name (default: "oauth_storage") */
+  tableName?: string;
+  /** Logger for debugging (default: no-op) */
+  logger?: Logger;
+}
+
+/**
+ * SQLite storage for OAuth sessions and tokens.
+ *
+ * Features:
+ * - Automatic table creation
+ * - TTL-based expiration
+ * - Works with any SQLite driver via adapters
+ * - JSON serialization for complex values
+ *
+ * @example Val.Town / libSQL
+ * ```typescript
+ * import { sqlite } from "https://esm.town/v/std/sqlite";
+ * import { SQLiteStorage, valTownAdapter } from "@tijs/atproto-storage";
+ *
+ * const storage = new SQLiteStorage(valTownAdapter(sqlite), {
+ *   tableName: "oauth_storage",
+ *   logger: console,
+ * });
+ *
+ * // Store with TTL
+ * await storage.set("session:123", { did: "did:plc:abc" }, { ttl: 3600 });
+ *
+ * // Retrieve
+ * const session = await storage.get("session:123");
+ * ```
+ *
+ * @example Deno native SQLite
+ * ```typescript
+ * import { Database } from "jsr:@db/sqlite";
+ * import { SQLiteStorage, denoSqliteAdapter } from "@tijs/atproto-storage";
+ *
+ * const db = new Database("storage.db");
+ * const storage = new SQLiteStorage(denoSqliteAdapter(db));
+ * ```
+ */
+export class SQLiteStorage implements OAuthStorage {
+  private initialized = false;
+  private readonly tableName: string;
+  private readonly logger: Logger;
+
+  constructor(
+    private adapter: SQLiteAdapter,
+    options?: SQLiteStorageOptions,
+  ) {
+    this.tableName = options?.tableName ?? "oauth_storage";
+    this.logger = options?.logger ?? noopLogger;
+  }
+
+  private async init(): Promise<void> {
+    if (this.initialized) return;
+
+    // Create table if it doesn't exist
+    await this.adapter.execute(
+      `
+        CREATE TABLE IF NOT EXISTS ${this.tableName} (
+          key TEXT PRIMARY KEY,
+          value TEXT NOT NULL,
+          expires_at TEXT,
+          created_at TEXT NOT NULL,
+          updated_at TEXT NOT NULL
+        )
+      `,
+      [],
+    );
+
+    // Create index on expires_at for efficient cleanup queries
+    await this.adapter.execute(
+      `CREATE INDEX IF NOT EXISTS idx_${this.tableName}_expires_at ON ${this.tableName}(expires_at)`,
+      [],
+    );
+
+    this.initialized = true;
+  }
+
+  async get<T = unknown>(key: string): Promise<T | null> {
+    await this.init();
+
+    const now = Date.now();
+    this.logger.log("[SQLiteStorage.get]", { key });
+
+    const rows = await this.adapter.execute(
+      `
+        SELECT value, expires_at FROM ${this.tableName}
+        WHERE key = ?
+        LIMIT 1
+      `,
+      [key],
+    );
+
+    if (rows.length === 0) {
+      this.logger.log("[SQLiteStorage.get] Key not found");
+      return null;
+    }
+
+    // Parse expires_at from TEXT to number
+    const expiresAtRaw = rows[0][1];
+    const expiresAt = expiresAtRaw !== null
+      ? parseInt(expiresAtRaw as string, 10)
+      : null;
+
+    // Check expiration
+    if (expiresAt !== null && expiresAt <= now) {
+      this.logger.log("[SQLiteStorage.get] Key expired");
+      return null;
+    }
+
+    try {
+      const value = rows[0][0] as string;
+      const parsed = JSON.parse(value) as T;
+      this.logger.log("[SQLiteStorage.get] Returning parsed value");
+      return parsed;
+    } catch {
+      this.logger.log("[SQLiteStorage.get] Returning raw value");
+      return rows[0][0] as T;
+    }
+  }
+
+  async set<T = unknown>(
+    key: string,
+    value: T,
+    options?: { ttl?: number },
+  ): Promise<void> {
+    await this.init();
+
+    const now = Date.now();
+    const expiresAt = options?.ttl ? now + (options.ttl * 1000) : null;
+    const serializedValue = typeof value === "string"
+      ? value
+      : JSON.stringify(value);
+
+    this.logger.log("[SQLiteStorage.set]", {
+      key,
+      ttl: options?.ttl,
+      expiresAt: expiresAt ? new Date(expiresAt).toISOString() : null,
+    });
+
+    await this.adapter.execute(
+      `
+        INSERT INTO ${this.tableName} (key, value, expires_at, created_at, updated_at)
+        VALUES (?, ?, ?, ?, ?)
+        ON CONFLICT(key) DO UPDATE SET
+          value = excluded.value,
+          expires_at = excluded.expires_at,
+          updated_at = excluded.updated_at
+      `,
+      [
+        key,
+        serializedValue,
+        expiresAt !== null ? expiresAt.toString() : null,
+        now.toString(),
+        now.toString(),
+      ],
+    );
+
+    this.logger.log("[SQLiteStorage.set] Stored successfully");
+  }
+
+  async delete(key: string): Promise<void> {
+    await this.init();
+
+    this.logger.log("[SQLiteStorage.delete]", { key });
+
+    await this.adapter.execute(
+      `DELETE FROM ${this.tableName} WHERE key = ?`,
+      [key],
+    );
+  }
+
+  /**
+   * Clean up expired entries from the database.
+   * Call this periodically to keep the table size manageable.
+   *
+   * @returns Number of entries deleted
+   */
+  async cleanup(): Promise<number> {
+    await this.init();
+
+    const now = Date.now();
+    this.logger.log("[SQLiteStorage.cleanup] Removing expired entries");
+
+    // Get count before deletion
+    const countRows = await this.adapter.execute(
+      `
+        SELECT COUNT(*) FROM ${this.tableName}
+        WHERE expires_at IS NOT NULL AND CAST(expires_at AS INTEGER) <= ?
+      `,
+      [now],
+    );
+
+    const count = countRows[0]?.[0] as number ?? 0;
+
+    if (count > 0) {
+      await this.adapter.execute(
+        `
+          DELETE FROM ${this.tableName}
+          WHERE expires_at IS NOT NULL AND CAST(expires_at AS INTEGER) <= ?
+        `,
+        [now],
+      );
+
+      this.logger.log(
+        `[SQLiteStorage.cleanup] Deleted ${count} expired entries`,
+      );
+    }
+
+    return count;
+  }
+}

src/storage.test.ts

···
+import { assertEquals, assertExists } from "@std/assert";
+import { MemoryStorage } from "./memory.ts";
+import { SQLiteStorage } from "./sqlite.ts";
+import { valTownAdapter } from "./adapters.ts";
+import type { SQLiteAdapter } from "./types.ts";
+
+// Mock SQLite database that implements the ExecutableDriver interface
+// (used with valTownAdapter to create an SQLiteAdapter)
+class MockExecutableDriver {
+  private tables = new Map<string, Map<string, unknown[]>>();
+
+  execute(
+    query: { sql: string; args: unknown[] },
+  ): Promise<{ rows: unknown[][] }> {
+    const sql = query.sql.trim();
+
+    // CREATE TABLE
+    if (sql.toUpperCase().startsWith("CREATE TABLE")) {
+      const match = sql.match(/CREATE TABLE IF NOT EXISTS (\w+)/i);
+      if (match) {
+        const tableName = match[1];
+        if (!this.tables.has(tableName)) {
+          this.tables.set(tableName, new Map());
+        }
+      }
+      return Promise.resolve({ rows: [] });
+    }
+
+    // CREATE INDEX
+    if (sql.toUpperCase().startsWith("CREATE INDEX")) {
+      return Promise.resolve({ rows: [] });
+    }
+
+    // INSERT
+    if (sql.toUpperCase().startsWith("INSERT")) {
+      const match = sql.match(/INSERT INTO (\w+)/i);
+      if (match) {
+        const tableName = match[1];
+        const table = this.tables.get(tableName) || new Map();
+        const key = query.args[0] as string;
+        table.set(key, query.args);
+        this.tables.set(tableName, table);
+      }
+      return Promise.resolve({ rows: [] });
+    }
+
+    // SELECT
+    if (sql.toUpperCase().startsWith("SELECT")) {
+      const countMatch = sql.match(/SELECT COUNT\(\*\) FROM (\w+)/i);
+      if (countMatch) {
+        return Promise.resolve({ rows: [[0]] });
+      }
+
+      const match = sql.match(/FROM (\w+)/i);
+      if (match) {
+        const tableName = match[1];
+        const table = this.tables.get(tableName);
+        if (table) {
+          const key = query.args[0] as string;
+          const row = table.get(key);
+          if (row) {
+            // Return value and expires_at (indices 1 and 2)
+            return Promise.resolve({
+              rows: [[row[1], row[2]]],
+            });
+          }
+        }
+      }
+      return Promise.resolve({ rows: [] });
+    }
+
+    // DELETE
+    if (sql.toUpperCase().startsWith("DELETE")) {
+      const match = sql.match(/FROM (\w+)/i);
+      if (match) {
+        const tableName = match[1];
+        const table = this.tables.get(tableName);
+        if (table) {
+          const key = query.args[0] as string;
+          table.delete(key);
+        }
+      }
+      return Promise.resolve({ rows: [] });
+    }
+
+    return Promise.resolve({ rows: [] });
+  }
+}
+
+// Direct mock adapter for testing (without going through valTownAdapter)
+function createMockAdapter(): SQLiteAdapter {
+  const tables = new Map<string, Map<string, unknown[]>>();
+
+  return {
+    execute: (sql: string, params: unknown[]): Promise<unknown[][]> => {
+      const trimmedSql = sql.trim();
+
+      // CREATE TABLE
+      if (trimmedSql.toUpperCase().startsWith("CREATE TABLE")) {
+        const match = trimmedSql.match(/CREATE TABLE IF NOT EXISTS (\w+)/i);
+        if (match) {
+          const tableName = match[1];
+          if (!tables.has(tableName)) {
+            tables.set(tableName, new Map());
+          }
+        }
+        return Promise.resolve([]);
+      }
+
+      // CREATE INDEX
+      if (trimmedSql.toUpperCase().startsWith("CREATE INDEX")) {
+        return Promise.resolve([]);
+      }
+
+      // INSERT
+      if (trimmedSql.toUpperCase().startsWith("INSERT")) {
+        const match = trimmedSql.match(/INSERT INTO (\w+)/i);
+        if (match) {
+          const tableName = match[1];
+          const table = tables.get(tableName) || new Map();
+          const key = params[0] as string;
+          table.set(key, params);
+          tables.set(tableName, table);
+        }
+        return Promise.resolve([]);
+      }
+
+      // SELECT
+      if (trimmedSql.toUpperCase().startsWith("SELECT")) {
+        const countMatch = trimmedSql.match(/SELECT COUNT\(\*\) FROM (\w+)/i);
+        if (countMatch) {
+          return Promise.resolve([[0]]);
+        }
+
+        const match = trimmedSql.match(/FROM (\w+)/i);
+        if (match) {
+          const tableName = match[1];
+          const table = tables.get(tableName);
+          if (table) {
+            const key = params[0] as string;
+            const row = table.get(key);
+            if (row) {
+              // Return value and expires_at (indices 1 and 2)
+              return Promise.resolve([[row[1], row[2]]]);
+            }
+          }
+        }
+        return Promise.resolve([]);
+      }
+
+      // DELETE
+      if (trimmedSql.toUpperCase().startsWith("DELETE")) {
+        const match = trimmedSql.match(/FROM (\w+)/i);
+        if (match) {
+          const tableName = match[1];
+          const table = tables.get(tableName);
+          if (table) {
+            const key = params[0] as string;
+            table.delete(key);
+          }
+        }
+        return Promise.resolve([]);
+      }
+
+      return Promise.resolve([]);
+    },
+  };
+}
+
+// ============ MemoryStorage Tests ============
+
+Deno.test("MemoryStorage - basic operations", async (t) => {
+  const storage = new MemoryStorage();
+
+  await t.step("set and get value", async () => {
+    await storage.set("key1", { foo: "bar" });
+    const result = await storage.get<{ foo: string }>("key1");
+    assertExists(result);
+    assertEquals(result.foo, "bar");
+  });
+
+  await t.step("get non-existent key returns null", async () => {
+    const result = await storage.get("nonexistent");
+    assertEquals(result, null);
+  });
+
+  await t.step("delete removes value", async () => {
+    await storage.set("key2", "value");
+    await storage.delete("key2");
+    const result = await storage.get("key2");
+    assertEquals(result, null);
+  });
+
+  await t.step("overwrite existing value", async () => {
+    await storage.set("key3", "first");
+    await storage.set("key3", "second");
+    const result = await storage.get("key3");
+    assertEquals(result, "second");
+  });
+});
+
+Deno.test("MemoryStorage - TTL expiration", async (t) => {
+  const storage = new MemoryStorage();
+
+  await t.step("value available before TTL", async () => {
+    await storage.set("ttl-key", "value", { ttl: 10 }); // 10 seconds
+    const result = await storage.get("ttl-key");
+    assertEquals(result, "value");
+  });
+
+  await t.step("value expired after TTL", async () => {
+    // Set with very short TTL
+    await storage.set("expired-key", "value", { ttl: 0.001 }); // 1ms
+    // Wait long enough to ensure expiration
+    await new Promise((r) => setTimeout(r, 50));
+    const result = await storage.get("expired-key");
+    assertEquals(result, null);
+  });
+
+  await t.step("value without TTL never expires", async () => {
+    await storage.set("no-ttl", "value");
+    const result = await storage.get("no-ttl");
+    assertEquals(result, "value");
+  });
+});
+
+Deno.test("MemoryStorage - helper methods", async (t) => {
+  await t.step("clear removes all entries", async () => {
+    const storage = new MemoryStorage();
+    await storage.set("a", 1);
+    await storage.set("b", 2);
+    assertEquals(storage.size, 2);
+
+    storage.clear();
+    assertEquals(storage.size, 0);
+  });
+
+  await t.step("size reflects entry count", async () => {
+    const storage = new MemoryStorage();
+    assertEquals(storage.size, 0);
+
+    await storage.set("a", 1);
+    assertEquals(storage.size, 1);
+
+    await storage.set("b", 2);
+    assertEquals(storage.size, 2);
+
+    await storage.delete("a");
+    assertEquals(storage.size, 1);
+  });
+});
+
+Deno.test("MemoryStorage - complex values", async (t) => {
+  const storage = new MemoryStorage();
+
+  await t.step("stores objects", async () => {
+    const obj = { nested: { deep: { value: 123 } } };
+    await storage.set("obj", obj);
+    const result = await storage.get<typeof obj>("obj");
+    assertEquals(result, obj);
+  });
+
+  await t.step("stores arrays", async () => {
+    const arr = [1, 2, 3, { four: 4 }];
+    await storage.set("arr", arr);
+    const result = await storage.get<typeof arr>("arr");
+    assertEquals(result, arr);
+  });
+
+  await t.step("stores null", async () => {
+    await storage.set("null", null);
+    const result = await storage.get("null");
+    assertEquals(result, null);
+  });
+});
+
+// ============ SQLiteStorage Tests ============
+
+Deno.test("SQLiteStorage - basic operations with direct adapter", async (t) => {
+  const adapter = createMockAdapter();
+  const storage = new SQLiteStorage(adapter);
+
+  await t.step("set and get value", async () => {
+    await storage.set("key1", { foo: "bar" });
+    const result = await storage.get<{ foo: string }>("key1");
+    assertExists(result);
+    assertEquals(result.foo, "bar");
+  });
+
+  await t.step("get non-existent key returns null", async () => {
+    const result = await storage.get("nonexistent");
+    assertEquals(result, null);
+  });
+
+  await t.step("delete removes value", async () => {
+    await storage.set("key2", "value");
+    await storage.delete("key2");
+    const result = await storage.get("key2");
+    assertEquals(result, null);
+  });
+});
+
+Deno.test("SQLiteStorage - with valTownAdapter", async (t) => {
+  const mockDriver = new MockExecutableDriver();
+  const adapter = valTownAdapter(mockDriver);
+  const storage = new SQLiteStorage(adapter);
+
+  await t.step("set and get value", async () => {
+    await storage.set("key1", { foo: "bar" });
+    const result = await storage.get<{ foo: string }>("key1");
+    assertExists(result);
+    assertEquals(result.foo, "bar");
+  });
+
+  await t.step("get non-existent key returns null", async () => {
+    const result = await storage.get("nonexistent");
+    assertEquals(result, null);
+  });
+
+  await t.step("delete removes value", async () => {
+    await storage.set("key2", "value");
+    await storage.delete("key2");
+    const result = await storage.get("key2");
+    assertEquals(result, null);
+  });
+});
+
+Deno.test("SQLiteStorage - custom options", async (t) => {
+  await t.step("accepts custom table name", async () => {
+    const adapter = createMockAdapter();
+    const storage = new SQLiteStorage(adapter, { tableName: "custom_table" });
+    await storage.set("key", "value");
+    const result = await storage.get("key");
+    assertEquals(result, "value");
+  });
+
+  await t.step("accepts custom logger", async () => {
+    const logs: string[] = [];
+    const logger = {
+      log: (...args: unknown[]) => logs.push(args.join(" ")),
+      warn: () => {},
+      error: () => {},
+    };
+
+    const adapter = createMockAdapter();
+    const storage = new SQLiteStorage(adapter, { logger });
+    await storage.set("key", "value");
+
+    assertEquals(logs.length > 0, true);
+  });
+});
+
+Deno.test("SQLiteStorage - TTL handling", async (t) => {
+  const adapter = createMockAdapter();
+  const storage = new SQLiteStorage(adapter);
+
+  await t.step("sets TTL when provided", async () => {
+    await storage.set("ttl-key", "value", { ttl: 3600 });
+    const result = await storage.get("ttl-key");
+    assertEquals(result, "value");
+  });
+
+  await t.step("no TTL when not provided", async () => {
+    await storage.set("no-ttl", "value");
+    const result = await storage.get("no-ttl");
+    assertEquals(result, "value");
+  });
+});
+
+// ============ Adapter Tests ============
+
+Deno.test("valTownAdapter - transforms execute signature", async () => {
+  let capturedSql = "";
+  let capturedParams: unknown[] = [];
+
+  const mockDriver = {
+    execute: (query: { sql: string; args: unknown[] }) => {
+      capturedSql = query.sql;
+      capturedParams = query.args;
+      return Promise.resolve({ rows: [["test-value", null]] });
+    },
+  };
+
+  const adapter = valTownAdapter(mockDriver);
+  const result = await adapter.execute("SELECT * FROM test WHERE id = ?", [
+    123,
+  ]);
+
+  assertEquals(capturedSql, "SELECT * FROM test WHERE id = ?");
+  assertEquals(capturedParams, [123]);
+  assertEquals(result, [["test-value", null]]);
+});

src/types.ts

···
+/**
+ * Storage interface for OAuth sessions and tokens.
+ * Compatible with @tijs/oauth-client-deno, @tijs/hono-oauth-sessions,
+ * and @tijs/atproto-sessions.
+ */
+export interface OAuthStorage {
+  /**
+   * Retrieve a value from storage
+   * @param key - Storage key
+   * @returns The value, or null if not found or expired
+   */
+  get<T = unknown>(key: string): Promise<T | null>;
+
+  /**
+   * Store a value in storage with optional TTL
+   * @param key - Storage key
+   * @param value - Value to store (will be JSON serialized)
+   * @param options - Optional settings
+   * @param options.ttl - Time-to-live in seconds
+   */
+  set<T = unknown>(
+    key: string,
+    value: T,
+    options?: { ttl?: number },
+  ): Promise<void>;
+
+  /**
+   * Delete a value from storage
+   * @param key - Storage key
+   */
+  delete(key: string): Promise<void>;
+}
+
+/**
+ * Minimal SQLite adapter interface.
+ * Adapts any SQLite driver to work with SQLiteStorage.
+ *
+ * Use one of the pre-built adapters or implement your own:
+ * - `valTownAdapter()` - For Val.Town sqlite and libSQL/Turso
+ * - `denoSqliteAdapter()` - For @db/sqlite (Deno native)
+ * - `betterSqlite3Adapter()` - For better-sqlite3 (Node.js)
+ *
+ * @example Custom adapter
+ * ```typescript
+ * const customAdapter: SQLiteAdapter = {
+ *   execute: async (sql, params) => {
+ *     const result = await myDriver.query(sql, params);
+ *     return result.rows;
+ *   }
+ * };
+ * ```
+ */
+export interface SQLiteAdapter {
+  /**
+   * Execute a SQL query with parameters.
+   * @param sql - SQL query string with ? placeholders
+   * @param params - Parameter values for placeholders
+   * @returns Array of rows, where each row is an array of column values
+   */
+  execute(sql: string, params: unknown[]): Promise<unknown[][]>;
+}
+
+/**
+ * Logger interface for debugging storage operations
+ */
+export interface Logger {
+  log(...args: unknown[]): void;
+  warn(...args: unknown[]): void;
+  error(...args: unknown[]): void;
+}