Class NodeSqliteAdapter

src/db/sqlite-adapter.ts:54–190

* Wraps Node's built-in `node:sqlite` (`DatabaseSync`) to match the * better-sqlite3 interface the rest of the code expects. * * node:sqlite is real SQLite compiled into Node, so it supports WAL, FTS5, * mmap, and `@named` params natively — the only shims needed are the * better-sqlite3 conveni

 * `.transaction()` helper, and `open` (node:sqlite exposes `isOpen`).
 */
class NodeSqliteAdapter implements SqliteDatabase {
  private _db: any;
  private _txDepth = 0;
  private readonly _dbPath: string;

  constructor(dbPath: string, opts?: { readOnly?: boolean }) {
    // eslint-disable-next-line @typescript-eslint/no-require-imports
    const { DatabaseSync } = require('node:sqlite');
    this._dbPath = dbPath;
    this._db = opts?.readOnly ? new DatabaseSync(dbPath, { readOnly: true }) : new DatabaseSync(dbPath);
  }

  /**
   * What a failed call throws: the error itself, or — for a "disk I/O error"
   * on a WSL index that Windows CodeGraph shares — the actionable rewrite
   * (#995). Every open runs its PRAGMAs and first reads through the methods
   * below, and so does every later query. `iterate()` is left raw: a
   * row-by-row wrapper would tax the unbounded scans it exists for, and a
   * session reads through `get`/`all` long before it reaches one.
   */
  private failure(err: unknown): unknown {
    return toWslSharedIndexError(err, this._dbPath) ?? err;
  }

  get inTransaction(): boolean | undefined {
    return this._db.isTransaction;
  }

  get open(): boolean {
    return this._db.isOpen;
  }

  prepare(sql: string): SqliteStatement {
    // node:sqlite matches better-sqlite3's calling convention (variadic
    // positional args, or a single object for @named params), so params forward
    // through unchanged.
    let stmt: any;
    try {
      stmt = this._db.prepare(sql);
    } catch (err) {
      throw this.failure(err);
    }
    const failure = (err: unknown): unknown => this.failure(err);
    return {
      run(...params: any[]) {
        let r: any;
        try {
          r = stmt.run(...params);
        } catch (err) {
          throw failure(err);
        }
        return {
          changes: Number(r?.changes ?? 0),
          lastInsertRowid: r?.lastInsertRowid ?? 0,
        };
      },
      get(...params: any[]) {
        try {