@nextlyhq/adapter-sqlite 0.0.1

package/LICENSE

@@ -0,0 +1,22 @@
+MIT License
+
+Copyright (c) 2026 NextlyHQ <info@nextlyhq.com>
+
+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.

package/README.md

@@ -0,0 +1,102 @@
+# @nextlyhq/adapter-sqlite
+
+SQLite database adapter for Nextly. Built on `better-sqlite3` for synchronous file-based persistence.
+
+<p align="center">
+  <a href="https://www.npmjs.com/package/@nextlyhq/adapter-sqlite"><img alt="npm" src="https://img.shields.io/npm/v/@nextlyhq/adapter-sqlite?style=flat-square&label=npm&color=cb3837" /></a>
+  <a href="https://github.com/nextlyhq/nextly/blob/main/LICENSE.md"><img alt="License" src="https://img.shields.io/github/license/nextlyhq/nextly?style=flat-square&color=blue" /></a>
+  <a href="https://nextlyhq.com/docs"><img alt="Status" src="https://img.shields.io/badge/status-alpha-orange?style=flat-square" /></a>
+</p>
+
+> [!IMPORTANT]
+> Nextly is in alpha. APIs may change before 1.0. Pin exact versions in production.
+
+> [!WARNING]
+> **SQLite is for local demos and quick experiments only.** It is single-writer, file-based, has no SSL, and emulates several features (see [Dialect notes](#dialect-notes) below). The adapter exists so you can try Nextly without provisioning a database server. For any real project, even local development, use [`@nextlyhq/adapter-postgres`](../adapter-postgres). The fastest way to run Postgres locally is `docker compose up -d postgres`.
+
+## What it is
+
+The SQLite adapter for Nextly. Use this for one-off local demos or quick experiments where setting up a database server would be friction.
+
+For any project beyond a quick demo, use [`@nextlyhq/adapter-postgres`](../adapter-postgres). PostgreSQL has the full feature set Nextly is designed around; SQLite emulates a subset.
+
+## Installation
+
+```bash
+pnpm add @nextlyhq/adapter-sqlite better-sqlite3
+```
+
+## Quick usage
+
+Nextly selects the adapter from your `.env` file. Install the package and set:
+
+```bash
+DB_DIALECT=sqlite
+DATABASE_URL=file:./data/nextly.db
+```
+
+The path can be relative (resolved against the project root) or absolute. The directory must exist.
+
+## Required environment variables
+
+| Variable       | Required?   | Default                  | Notes                                          |
+| -------------- | ----------- | ------------------------ | ---------------------------------------------- |
+| `DATABASE_URL` | yes         | (none)                   | `file:./path/to/db.sqlite` or absolute path.   |
+| `DB_DIALECT`   | recommended | (auto-detected from URL) | Set explicitly to silence the warning at boot. |
+
+## Programmatic usage (advanced)
+
+For test harnesses or scripts:
+
+```ts
+import { createSqliteAdapter } from "@nextlyhq/adapter-sqlite";
+
+const adapter = createSqliteAdapter({
+  url: process.env.DATABASE_URL!,
+});
+
+await adapter.connect();
+```
+
+Most users do not need this.
+
+## Supported SQLite versions
+
+- SQLite 3.38 or newer required (bundled with `better-sqlite3`)
+
+## Dialect notes
+
+- **Single writer.** SQLite serializes writes; concurrent transactions queue. Fine for one user, painful for production traffic.
+- **No SSL or TLS.** Not applicable to a local file.
+- **Limited types.** No native arrays, no JSONB; JSON is stored as TEXT. ILIKE is emulated as `LOWER(...) LIKE LOWER(...)`.
+- **Savepoints.** Supported.
+- **`RETURNING` clause.** Supported (SQLite 3.35+).
+
+## Main exports
+
+- `SqliteAdapter`: the adapter class
+- `createSqliteAdapter`: factory for programmatic use
+- `isSqliteAdapter`: type guard
+- Type exports: `SqliteAdapterConfig`
+
+## Compatibility
+
+| Tool             | Version |
+| ---------------- | ------- |
+| Node.js          | 20+     |
+| `better-sqlite3` | 11+     |
+| `nextly`         | 0.0.x   |
+
+## Documentation
+
+- [**SQLite adapter docs**](https://nextlyhq.com/docs/database/sqlite)
+- [**Database support and version policy**](https://nextlyhq.com/docs/database/support)
+
+## Related packages
+
+- [`@nextlyhq/adapter-postgres`](../adapter-postgres): recommended for production
+- [`@nextlyhq/adapter-mysql`](../adapter-mysql)
+
+## License
+
+[MIT](../../LICENSE.md)

package/dist/index.cjs

@@ -0,0 +1,572 @@
+'use strict';
+
+var adapterDrizzle = require('@nextlyhq/adapter-drizzle');
+var types = require('@nextlyhq/adapter-drizzle/types');
+var versionCheck = require('@nextlyhq/adapter-drizzle/version-check');
+var betterSqlite3 = require('drizzle-orm/better-sqlite3');
+
+// src/index.ts
+var VERSION = "0.1.0";
+var SQLITE_ERROR_CODES = {
+  // Constraint violations
+  SQLITE_CONSTRAINT: "constraint",
+  SQLITE_CONSTRAINT_UNIQUE: "unique_violation",
+  SQLITE_CONSTRAINT_PRIMARYKEY: "unique_violation",
+  SQLITE_CONSTRAINT_FOREIGNKEY: "foreign_key_violation",
+  SQLITE_CONSTRAINT_NOTNULL: "not_null_violation",
+  SQLITE_CONSTRAINT_CHECK: "check_violation",
+  // Busy/locked errors
+  SQLITE_BUSY: "timeout",
+  SQLITE_LOCKED: "timeout",
+  // Connection errors
+  SQLITE_CANTOPEN: "connection",
+  SQLITE_NOTADB: "connection",
+  SQLITE_CORRUPT: "connection",
+  // Query errors
+  SQLITE_ERROR: "query",
+  SQLITE_MISUSE: "query",
+  SQLITE_RANGE: "query"
+};
+var DEFAULT_CONFIG = {
+  busyTimeout: 5e3,
+  wal: true,
+  foreignKeys: true
+};
+function sanitizeSqliteValue(v) {
+  if (v === void 0) return null;
+  if (typeof v === "boolean") return v ? 1 : 0;
+  if (v instanceof Date) return v.toISOString();
+  if (v !== null && typeof v === "object") return JSON.stringify(v);
+  return v;
+}
+var SqliteAdapter = class extends adapterDrizzle.DrizzleAdapter {
+  /**
+   * The database dialect - always 'sqlite' for this adapter.
+   */
+  dialect = "sqlite";
+  /**
+   * Adapter configuration.
+   */
+  config;
+  /**
+   * better-sqlite3 Database instance.
+   */
+  db = null;
+  /**
+   * Connection state flag.
+   */
+  connected = false;
+  /**
+   * Serialization queue for concurrent `transaction()` calls.
+   *
+   * better-sqlite3 is synchronous, single-connection, and rejects nested
+   * `BEGIN` with "cannot start a transaction within a transaction".
+   * When two `await adapter.transaction(...)` calls overlap (e.g. a bulk
+   * mutation calling `Promise.allSettled` with N per-row updates), the
+   * second one tries to BEGIN while the first is still open and the
+   * driver throws.
+   *
+   * Postgres/MySQL avoid this by allocating a fresh client/connection
+   * per transaction from a pool — there is no equivalent for
+   * better-sqlite3, so we serialize at the JS layer instead. Every
+   * `transaction()` invocation chains onto this promise; only one
+   * BEGIN→COMMIT/ROLLBACK section runs at any moment, preserving
+   * write-isolation semantics that callers expect from a transactional
+   * adapter.
+   *
+   * Performance impact is the natural floor: SQLite already serializes
+   * writers at the file-lock level, so the queue removes failed-call
+   * surface area without changing the achievable concurrency.
+   */
+  transactionQueue = Promise.resolve();
+  /**
+   * Creates a new SQLite adapter instance.
+   *
+   * @param config - Adapter configuration
+   */
+  constructor(config) {
+    super();
+    this.config = config;
+  }
+  /**
+   * Connect to the SQLite database.
+   *
+   * @remarks
+   * This method initializes the database connection. For SQLite, this
+   * opens the database file or creates an in-memory database.
+   * Also configures WAL mode and foreign keys based on config.
+   *
+   * @throws {DatabaseError} If connection fails
+   */
+  async connect() {
+    if (this.connected && this.db) {
+      return;
+    }
+    try {
+      const BetterSqlite3 = await import('better-sqlite3');
+      const Database = BetterSqlite3.default;
+      let dbPath;
+      if (this.config.memory) {
+        dbPath = ":memory:";
+      } else if (this.config.url) {
+        dbPath = this.config.url.replace(/^file:/, "");
+      } else {
+        dbPath = ":memory:";
+      }
+      if (dbPath !== ":memory:" && !this.config.readonly) {
+        const fs = await import('fs');
+        const path = await import('path');
+        const dir = path.dirname(path.resolve(dbPath));
+        await fs.promises.mkdir(dir, { recursive: true });
+      }
+      this.db = new Database(dbPath, {
+        readonly: this.config.readonly ?? false,
+        timeout: this.config.busyTimeout ?? DEFAULT_CONFIG.busyTimeout
+      });
+      if ((this.config.wal ?? DEFAULT_CONFIG.wal) && dbPath !== ":memory:" && !this.config.readonly) {
+        this.db.pragma("journal_mode = WAL");
+      }
+      if (this.config.foreignKeys ?? DEFAULT_CONFIG.foreignKeys) {
+        this.db.pragma("foreign_keys = ON");
+      }
+      await versionCheck.checkDialectVersion(this.db, "sqlite");
+      this.connected = true;
+      if (this.config.logger?.info) {
+        this.config.logger.info("SQLite connection established", {
+          url: dbPath === ":memory:" ? "in-memory" : dbPath,
+          wal: this.config.wal ?? DEFAULT_CONFIG.wal,
+          foreignKeys: this.config.foreignKeys ?? DEFAULT_CONFIG.foreignKeys
+        });
+      }
+    } catch (error) {
+      if (this.db) {
+        try {
+          this.db.close();
+        } catch {
+        }
+        this.db = null;
+      }
+      throw this.classifyError(error);
+    }
+  }
+  /**
+   * Disconnect from the SQLite database.
+   *
+   * @remarks
+   * This method closes the database connection and releases resources.
+   */
+  // better-sqlite3 is synchronous; method is async to satisfy the DatabaseAdapter contract.
+  // eslint-disable-next-line @typescript-eslint/require-await
+  async disconnect() {
+    if (!this.db) {
+      return;
+    }
+    try {
+      this.db.close();
+      if (this.config.logger?.info) {
+        this.config.logger.info("SQLite connection closed");
+      }
+    } finally {
+      this.db = null;
+      this.connected = false;
+    }
+  }
+  /**
+   * Check if connected to the database.
+   */
+  isConnected() {
+    return this.connected && this.db !== null;
+  }
+  /**
+   * Get connection pool statistics.
+   *
+   * @remarks
+   * SQLite doesn't use connection pooling, so this returns null.
+   * The database is single-file with a single connection.
+   */
+  getPoolStats() {
+    return null;
+  }
+  /**
+   * Execute a raw SQL query.
+   *
+   * @param sql - SQL query string with $1, $2 placeholders (converted to ? for SQLite)
+   * @param params - Query parameters
+   * @returns Query results
+   *
+   * @throws {DatabaseError} If query execution fails
+   */
+  // better-sqlite3 is synchronous; method is async to satisfy the DatabaseAdapter contract.
+  // eslint-disable-next-line @typescript-eslint/require-await
+  async executeQuery(sql, params = []) {
+    const db = this.ensureDb();
+    const startTime = Date.now();
+    try {
+      const convertedSql = this.convertPlaceholders(sql);
+      const trimmedSql = convertedSql.trim().toUpperCase();
+      const isPragmaQuery = trimmedSql.startsWith("PRAGMA") && !trimmedSql.includes("=");
+      const isSelect = trimmedSql.startsWith("SELECT") || isPragmaQuery || trimmedSql.startsWith("WITH");
+      const hasReturning = trimmedSql.includes("RETURNING");
+      let result;
+      const sanitizedParams = params.map(sanitizeSqliteValue);
+      if (isSelect || hasReturning) {
+        const stmt = db.prepare(convertedSql);
+        result = stmt.all(...sanitizedParams);
+      } else {
+        const stmt = db.prepare(convertedSql);
+        const runResult = stmt.run(...sanitizedParams);
+        result = [
+          {
+            changes: runResult.changes,
+            lastInsertRowid: runResult.lastInsertRowid
+          }
+        ];
+      }
+      if (this.config.logger?.query) {
+        const durationMs = Date.now() - startTime;
+        this.config.logger.query(convertedSql, params, durationMs);
+      }
+      return result;
+    } catch (error) {
+      throw this.classifyError(error, sql);
+    }
+  }
+  /**
+   * Execute work within a transaction.
+   *
+   * @param work - Function containing transactional operations
+   * @param options - Transaction options (isolation level not fully supported in SQLite)
+   * @returns Result of the work function
+   *
+   * @remarks
+   * Uses better-sqlite3's native transaction handling which:
+   * - Automatically commits on success
+   * - Automatically rolls back on error
+   * - Converts nested transactions to savepoints
+   *
+   * Note: SQLite uses DEFERRED, IMMEDIATE, or EXCLUSIVE transaction modes
+   * rather than isolation levels. This adapter uses IMMEDIATE by default.
+   */
+  async transaction(work, _options) {
+    const run = async () => this.runTransaction(work);
+    const next = this.transactionQueue.then(run, run);
+    this.transactionQueue = next.catch(() => void 0);
+    return next;
+  }
+  /**
+   * Inner transaction body. Kept private so callers always go through
+   * the serialized `transaction()` queue above and the BEGIN/COMMIT
+   * pair is never invoked outside of it.
+   */
+  async runTransaction(work) {
+    const db = this.ensureDb();
+    const startTime = Date.now();
+    try {
+      const ctx = this.createTransactionContext(db);
+      db.exec("BEGIN IMMEDIATE");
+      try {
+        const result = await work(ctx);
+        db.exec("COMMIT");
+        if (this.config.logger?.debug) {
+          const durationMs = Date.now() - startTime;
+          this.config.logger.debug("Transaction committed", {
+            durationMs
+          });
+        }
+        return result;
+      } catch (error) {
+        try {
+          db.exec("ROLLBACK");
+        } catch {
+        }
+        throw error;
+      }
+    } catch (error) {
+      throw this.classifyError(error);
+    }
+  }
+  /**
+   * Get SQLite database capabilities.
+   *
+   * @remarks
+   * SQLite capabilities:
+   * - JSON support (not JSONB)
+   * - No arrays
+   * - No native ILIKE
+   * - RETURNING clause (3.35+)
+   * - Savepoints supported
+   * - ON CONFLICT supported
+   */
+  getCapabilities() {
+    return {
+      dialect: "sqlite",
+      supportsJsonb: false,
+      // SQLite uses JSON, not JSONB
+      supportsJson: true,
+      supportsArrays: false,
+      // SQLite doesn't support array types
+      supportsGeneratedColumns: true,
+      // SQLite 3.31+
+      supportsFts: true,
+      // SQLite FTS5
+      supportsIlike: false,
+      // No native ILIKE, use LOWER() LIKE
+      supportsReturning: true,
+      // SQLite 3.35+
+      supportsSavepoints: true,
+      // SQLite supports savepoints
+      supportsOnConflict: true,
+      // ON CONFLICT clause
+      maxParamsPerQuery: 999,
+      // SQLite SQLITE_MAX_VARIABLE_NUMBER default
+      maxIdentifierLength: 128
+      // SQLite doesn't have a strict limit
+    };
+  }
+  /**
+   * Override insertMany for bulk insert optimization.
+   *
+   * @remarks
+   * Uses a single multi-row INSERT statement for better performance.
+   */
+  async insertMany(table, data, options) {
+    if (data.length === 0) {
+      return [];
+    }
+    const db = this.ensureDb();
+    if (data.length === 1) {
+      const result = await this.insert(table, data[0], options);
+      return [result];
+    }
+    const columns = Object.keys(data[0]);
+    const params = [];
+    const valuesClauses = [];
+    for (const record of data) {
+      const placeholders = [];
+      for (const col of columns) {
+        params.push(sanitizeSqliteValue(record[col]));
+        placeholders.push("?");
+      }
+      valuesClauses.push(`(${placeholders.join(", ")})`);
+    }
+    const columnList = columns.map((col) => this.escapeIdentifier(col)).join(", ");
+    let sql = `INSERT INTO ${this.escapeIdentifier(table)} (${columnList}) VALUES ${valuesClauses.join(", ")}`;
+    if (options?.returning) {
+      const returning = options.returning === "*" ? "*" : options.returning.map((col) => this.escapeIdentifier(col)).join(", ");
+      sql += ` RETURNING ${returning}`;
+    } else {
+      sql += " RETURNING *";
+    }
+    try {
+      const stmt = db.prepare(sql);
+      const rows = stmt.all(...params);
+      return rows;
+    } catch (error) {
+      throw this.handleQueryError(error, "insertMany", table);
+    }
+  }
+  // ============================================================
+  // Protected Helper Methods
+  // ============================================================
+  /**
+   * Ensures database is connected and returns it.
+   *
+   * @throws {DatabaseError} If not connected
+   */
+  ensureDb() {
+    if (!this.db) {
+      throw types.createDatabaseError({
+        kind: "connection",
+        message: "SqliteAdapter is not connected. Call connect() first."
+      });
+    }
+    return this.db;
+  }
+  /**
+   * Return the typed Drizzle instance for SQLite.
+   * Guarded for server-only usage and requires an active connection.
+   *
+   * @param schema - Optional schema for relational queries (db.query.*)
+   * @returns Drizzle ORM instance wrapping the better-sqlite3 connection
+   * @throws {Error} If called in browser or not connected
+   */
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  getDrizzle(schema) {
+    if (typeof window !== "undefined") {
+      throw new Error("getDrizzle() is server-only");
+    }
+    const db = this.ensureDb();
+    return schema ? betterSqlite3.drizzle(db, { schema }) : betterSqlite3.drizzle(db);
+  }
+  /**
+   * Convert $1, $2 placeholders to ? for better-sqlite3.
+   *
+   * @param sql - SQL with PostgreSQL-style placeholders
+   * @returns SQL with ? placeholders
+   */
+  convertPlaceholders(sql) {
+    return sql.replace(/\$\d+/g, "?");
+  }
+  /**
+   * Creates a TransactionContext for the given database connection.
+   */
+  createTransactionContext(db) {
+    return {
+      // eslint-disable-next-line @typescript-eslint/require-await
+      execute: async (sql, params = []) => {
+        const convertedSql = this.convertPlaceholders(sql);
+        const trimmedSql = convertedSql.trim().toUpperCase();
+        const isSelect = trimmedSql.startsWith("SELECT") || trimmedSql.includes("RETURNING");
+        const sanitizedParams = params.map(sanitizeSqliteValue);
+        if (isSelect) {
+          const stmt = db.prepare(convertedSql);
+          return stmt.all(...sanitizedParams);
+        } else {
+          const stmt = db.prepare(convertedSql);
+          const result = stmt.run(...sanitizedParams);
+          return [
+            {
+              changes: result.changes,
+              lastInsertRowid: result.lastInsertRowid
+            }
+          ];
+        }
+      },
+      // eslint-disable-next-line @typescript-eslint/require-await
+      insert: async (table, data, options) => {
+        const columns = Object.keys(data);
+        const values = Object.values(data).map(sanitizeSqliteValue);
+        const placeholders = values.map(() => "?").join(", ");
+        let sql = `INSERT INTO ${this.escapeIdentifier(table)} (${columns.map((c) => this.escapeIdentifier(c)).join(", ")}) VALUES (${placeholders})`;
+        if (options?.returning) {
+          const returning = options.returning === "*" ? "*" : options.returning.map((col) => this.escapeIdentifier(col)).join(", ");
+          sql += ` RETURNING ${returning}`;
+        } else {
+          sql += " RETURNING *";
+        }
+        const stmt = db.prepare(sql);
+        const rows = stmt.all(...values);
+        return rows[0];
+      },
+      // eslint-disable-next-line @typescript-eslint/require-await
+      insertMany: async (table, data, options) => {
+        if (data.length === 0) return [];
+        const columns = Object.keys(data[0]);
+        const allValues = [];
+        const valuesClauses = [];
+        for (const record of data) {
+          const placeholders = [];
+          for (const col of columns) {
+            allValues.push(sanitizeSqliteValue(record[col]));
+            placeholders.push("?");
+          }
+          valuesClauses.push(`(${placeholders.join(", ")})`);
+        }
+        let sql = `INSERT INTO ${this.escapeIdentifier(table)} (${columns.map((c) => this.escapeIdentifier(c)).join(", ")}) VALUES ${valuesClauses.join(", ")}`;
+        if (options?.returning) {
+          const returning = options.returning === "*" ? "*" : options.returning.map((col) => this.escapeIdentifier(col)).join(", ");
+          sql += ` RETURNING ${returning}`;
+        } else {
+          sql += " RETURNING *";
+        }
+        const stmt = db.prepare(sql);
+        return stmt.all(...allValues);
+      },
+      // TransactionContext CRUD methods delegate to the adapter's CRUD
+      // which uses Drizzle query API via the TableResolver.
+      select: async (table, options) => {
+        return this.select(table, options);
+      },
+      selectOne: async (table, options) => {
+        return this.selectOne(table, options);
+      },
+      update: async (table, data, where, options) => {
+        return this.update(table, data, where, options);
+      },
+      delete: async (table, where, _options) => {
+        return this.delete(table, where);
+      },
+      upsert: async (table, data, options) => {
+        return this.upsert(table, data, options);
+      },
+      // eslint-disable-next-line @typescript-eslint/require-await
+      savepoint: async (name) => {
+        db.exec(`SAVEPOINT ${this.escapeIdentifier(name)}`);
+      },
+      // eslint-disable-next-line @typescript-eslint/require-await
+      rollbackToSavepoint: async (name) => {
+        db.exec(`ROLLBACK TO SAVEPOINT ${this.escapeIdentifier(name)}`);
+      },
+      // eslint-disable-next-line @typescript-eslint/require-await
+      releaseSavepoint: async (name) => {
+        db.exec(`RELEASE SAVEPOINT ${this.escapeIdentifier(name)}`);
+      }
+    };
+  }
+  /**
+   * Classifies a SQLite error into a DatabaseError.
+   *
+   * @param error - Original error from better-sqlite3
+   * @param sql - SQL statement that caused the error (optional)
+   * @returns DatabaseError with proper classification
+   */
+  classifyError(error, sql) {
+    if (types.isDatabaseError(error)) return error;
+    const sqliteError = error;
+    let kind = "unknown";
+    if (sqliteError.code) {
+      kind = SQLITE_ERROR_CODES[sqliteError.code] || "unknown";
+    } else if (sqliteError.message) {
+      const msg = sqliteError.message.toUpperCase();
+      if (msg.includes("UNIQUE CONSTRAINT")) {
+        kind = "unique_violation";
+      } else if (msg.includes("FOREIGN KEY CONSTRAINT")) {
+        kind = "foreign_key_violation";
+      } else if (msg.includes("NOT NULL CONSTRAINT")) {
+        kind = "not_null_violation";
+      } else if (msg.includes("CHECK CONSTRAINT")) {
+        kind = "check_violation";
+      } else if (msg.includes("BUSY") || msg.includes("LOCKED")) {
+        kind = "timeout";
+      } else if (msg.includes("SQLITE_CANTOPEN") || msg.includes("UNABLE TO OPEN")) {
+        kind = "connection";
+      }
+    }
+    let message = sqliteError.message ?? String(error);
+    if (sql && kind === "query") {
+      message = `Query failed: ${message}`;
+    }
+    return types.createDatabaseError({
+      kind,
+      message,
+      code: sqliteError.code,
+      cause: error instanceof Error ? error : void 0
+    });
+  }
+  /**
+   * Override handleQueryError to use SQLite-specific classification.
+   */
+  handleQueryError(error, operation, table) {
+    const dbError = this.classifyError(error);
+    if (!dbError.message.includes(operation)) {
+      dbError.message = `${operation} operation failed on table '${table}': ${dbError.message}`;
+    }
+    if (!dbError.table) {
+      dbError.table = table;
+    }
+    return dbError;
+  }
+};
+function createSqliteAdapter(config) {
+  return new SqliteAdapter(config);
+}
+function isSqliteAdapter(value) {
+  return value instanceof SqliteAdapter;
+}
+
+exports.SqliteAdapter = SqliteAdapter;
+exports.VERSION = VERSION;
+exports.createSqliteAdapter = createSqliteAdapter;
+exports.isSqliteAdapter = isSqliteAdapter;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map