Rename valTownAdapter to sqliteAdapter

BREAKING CHANGE: valTownAdapter has been renamed to sqliteAdapter.
The adapter works with any SQLite driver using the execute({ sql, args })
pattern - not just Val Town. This includes Val Town, libSQL, and Turso.

CHANGELOG.md

···
 
 All notable changes to this project will be documented in this file.
 
+## [1.0.0] - 2025-12-05
+
+### Breaking Changes
+
+- Renamed `valTownAdapter` to `sqliteAdapter` - the adapter works with any
+  SQLite driver using the `execute({ sql, args })` pattern (Val.Town, libSQL,
+  Turso, etc.)
+
+### Migration
+
+Replace:
+
+```typescript
+import { valTownAdapter } from "@tijs/atproto-storage";
+```
+
+With:
+
+```typescript
+import { sqliteAdapter } from "@tijs/atproto-storage";
+```
+
 ## [0.1.1] - 2025-11-27
 
 ### Fixed

deno.json

···
 {
   "$schema": "https://jsr.io/schema/config-file.v1.json",
   "name": "@tijs/atproto-storage",
-  "version": "0.1.1",
+  "version": "1.0.0",
   "license": "MIT",
   "exports": "./mod.ts",
   "publish": {

mod.ts

···
  * - In-memory storage (for testing/development)
  * - SQLite storage (works with any SQLite driver via adapters)
  *
- * @example Val.Town / libSQL
+ * @example Val.Town / libSQL / Turso
  * ```typescript
  * import { sqlite } from "https://esm.town/v/std/sqlite";
- * import { SQLiteStorage, valTownAdapter } from "@tijs/atproto-storage";
+ * import { SQLiteStorage, sqliteAdapter } from "@tijs/atproto-storage";
  *
- * const storage = new SQLiteStorage(valTownAdapter(sqlite));
+ * const storage = new SQLiteStorage(sqliteAdapter(sqlite));
  * ```
  *
  * @example Deno native SQLite
···
 export {
   betterSqlite3Adapter,
   denoSqliteAdapter,
-  valTownAdapter,
+  sqliteAdapter,
 } from "./src/adapters.ts";
 export type { ExecutableDriver, PrepareDriver } from "./src/adapters.ts";

src/adapters.ts

···
 }
 
 /**
- * Adapter for Val.Town sqlite and libSQL/Turso client.
- * These drivers share the same execute({ sql, args }) API pattern.
+ * Adapter for SQLite drivers using the execute({ sql, args }) pattern.
+ * Works with Val.Town sqlite, libSQL/Turso, and similar drivers.
  *
  * @example Val.Town
  * ```typescript
  * import { sqlite } from "https://esm.town/v/std/sqlite";
- * import { SQLiteStorage, valTownAdapter } from "@tijs/atproto-storage";
+ * import { SQLiteStorage, sqliteAdapter } from "@tijs/atproto-storage";
  *
- * const storage = new SQLiteStorage(valTownAdapter(sqlite));
+ * const storage = new SQLiteStorage(sqliteAdapter(sqlite));
  * ```
  *
  * @example libSQL/Turso
  * ```typescript
  * import { createClient } from "@libsql/client";
- * import { SQLiteStorage, valTownAdapter } from "@tijs/atproto-storage";
+ * import { SQLiteStorage, sqliteAdapter } from "@tijs/atproto-storage";
  *
  * const client = createClient({ url: "libsql://..." });
- * const storage = new SQLiteStorage(valTownAdapter(client));
+ * const storage = new SQLiteStorage(sqliteAdapter(client));
  * ```
  */
-export function valTownAdapter(driver: ExecutableDriver): SQLiteAdapter {
+export function sqliteAdapter(driver: ExecutableDriver): SQLiteAdapter {
   return {
     execute: async (sql: string, params: unknown[]): Promise<unknown[][]> => {
       const result = await driver.execute({ sql, args: params });

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 { sqliteAdapter } from "./adapters.ts";
 import type { SQLiteAdapter } from "./types.ts";
 
 // Mock SQLite database that implements the ExecutableDriver interface
-// (used with valTownAdapter to create an SQLiteAdapter)
+// (used with sqliteAdapter to create an SQLiteAdapter)
 class MockExecutableDriver {
   private tables = new Map<string, Map<string, unknown[]>>();
 
···
   });
 });
 
-Deno.test("SQLiteStorage - with valTownAdapter", async (t) => {
+Deno.test("SQLiteStorage - with sqliteAdapter", async (t) => {
   const mockDriver = new MockExecutableDriver();
-  const adapter = valTownAdapter(mockDriver);
+  const adapter = sqliteAdapter(mockDriver);
   const storage = new SQLiteStorage(adapter);
 
   await t.step("set and get value", async () => {
···
 
 // ============ Adapter Tests ============
 
-Deno.test("valTownAdapter - transforms execute signature", async () => {
+Deno.test("sqliteAdapter - transforms execute signature", async () => {
   let capturedSql = "";
   let capturedParams: unknown[] = [];
 
···
     },
   };
 
-  const adapter = valTownAdapter(mockDriver);
+  const adapter = sqliteAdapter(mockDriver);
   const result = await adapter.execute("SELECT * FROM test WHERE id = ?", [
     123,
   ]);