tempest-db-js 0.7.0 → 0.8.0

package/dist/index.cjs

@@ -2047,6 +2047,68 @@ var NodeSqliteDriver = class _NodeSqliteDriver {
     this.db.close();
   }
 };
+var BetterSqliteDriver = class _BetterSqliteDriver {
+  // biome-ignore lint/suspicious/noExplicitAny: the peer dep's types are optional here.
+  db;
+  /** Prepared-statement cache keyed by SQL text — see {@link NodeSqliteDriver}. */
+  // biome-ignore lint/suspicious/noExplicitAny: see above.
+  statements = /* @__PURE__ */ new Map();
+  // biome-ignore lint/suspicious/noExplicitAny: accept an already-open Database handle.
+  constructor(database) {
+    this.db = database;
+  }
+  /**
+   * Open a `better-sqlite3` database at the given path (or `":memory:"`).
+   *
+   * @param path The database file, or `":memory:"`.
+   * @param options Passed straight to `new Database()` (`readonly`, `timeout`, …).
+   * @returns A driver over the open handle.
+   * @throws If `better-sqlite3` is not installed — it is an optional peer
+   *   dependency, so the error names the package to install.
+   */
+  static open(path, options) {
+    let Database;
+    try {
+      const mod = nodeRequire("better-sqlite3");
+      Database = mod.default ?? mod;
+    } catch (cause) {
+      throw new Error(
+        'The "better-sqlite3" driver requires the better-sqlite3 package: npm install better-sqlite3',
+        { cause }
+      );
+    }
+    return new _BetterSqliteDriver(
+      options ? new Database(path, { ...options }) : new Database(path)
+    );
+  }
+  /** Return the cached prepared statement for `sql`, preparing it on first use. */
+  // biome-ignore lint/suspicious/noExplicitAny: statement type is optional here.
+  prepare(sql2) {
+    const cached = this.statements.get(sql2);
+    if (cached) return cached;
+    const stmt = this.db.prepare(sql2);
+    this.statements.set(sql2, stmt);
+    return stmt;
+  }
+  execute(sql2, params) {
+    const stmt = this.prepare(sql2);
+    const bound = params.map(encodeSqliteParam);
+    if (stmt.reader) {
+      return { rows: stmt.all(...bound), changes: 0 };
+    }
+    const info = stmt.run(...bound);
+    return { rows: [], changes: Number(info.changes ?? 0) };
+  }
+  *iterate(sql2, params) {
+    const stmt = this.prepare(sql2);
+    const bound = params.map(encodeSqliteParam);
+    yield* stmt.iterate(...bound);
+  }
+  close() {
+    this.statements.clear();
+    this.db.close();
+  }
+};
 function returnsRows(sql2) {
   return /^\s*(select|pragma)/i.test(sql2) || /\breturning\b/i.test(sql2);
 }
@@ -2570,8 +2632,43 @@ function asAsync(driver) {
     } : {}
   };
 }
-function openSqliteDriver(path, options) {
-  return NodeSqliteDriver.open(path, options?.driverOptions);
+var SQLITE_DRIVER_ALIASES = {
+  "node:sqlite": "node:sqlite",
+  "node-sqlite": "node:sqlite",
+  node: "node:sqlite",
+  "better-sqlite3": "better-sqlite3",
+  better_sqlite3: "better-sqlite3",
+  bettersqlite3: "better-sqlite3"
+};
+var SERVER_DRIVER_ALIASES = {
+  postgresql: ["postgres", "postgres.js", "postgresjs", "pg"],
+  mysql: ["mysql", "mysql2"]
+};
+function checkServerDriver(dialect, driver) {
+  if (!driver) return;
+  const accepted = SERVER_DRIVER_ALIASES[dialect] ?? [];
+  if (accepted.includes(driver.toLowerCase())) return;
+  throw new Error(
+    `Unknown ${dialect} driver ${JSON.stringify(driver)}; tempest-db-js runs ${dialect} on ${JSON.stringify(accepted[0])}.`
+  );
+}
+function resolveSqliteDriver(parsed, options) {
+  const explicit = options?.driver;
+  if (explicit) {
+    const resolved = SQLITE_DRIVER_ALIASES[explicit.toLowerCase()];
+    if (!resolved) {
+      throw new Error(
+        `Unknown SQLite driver ${JSON.stringify(explicit)}; supported: "node:sqlite" (built-in, default) and "better-sqlite3".`
+      );
+    }
+    return resolved;
+  }
+  const fromUrl = parsed.driver ? SQLITE_DRIVER_ALIASES[parsed.driver.toLowerCase()] : void 0;
+  return fromUrl ?? "node:sqlite";
+}
+function openSqliteDriver(parsed, options) {
+  const path = parsed.database ?? ":memory:";
+  return resolveSqliteDriver(parsed, options) === "better-sqlite3" ? BetterSqliteDriver.open(path, options?.driverOptions) : NodeSqliteDriver.open(path, options?.driverOptions);
 }
 function createSyncEngine(url, options) {
   const parsed = parseDatabaseUrl(url);
@@ -2580,27 +2677,26 @@ function createSyncEngine(url, options) {
       `createSyncEngine supports only SQLite; ${parsed.dialect} is async-only \u2014 use createEngine.`
     );
   }
-  return new SyncEngine(
-    openSqliteDriver(parsed.database ?? ":memory:", options),
-    options?.onQuery
-  );
+  return new SyncEngine(openSqliteDriver(parsed, options), options?.onQuery);
 }
 function createEngine(url, options) {
   const parsed = parseDatabaseUrl(url);
   if (parsed.dialect === "sqlite") {
     return new AsyncEngine(
-      asAsync(openSqliteDriver(parsed.database ?? ":memory:", options)),
+      asAsync(openSqliteDriver(parsed, options)),
       "sqlite",
       options?.onQuery
     );
   }
   if (parsed.dialect === "mysql") {
+    checkServerDriver("mysql", options?.driver);
     return new AsyncEngine(
       createMysqlDriver(parsed.raw, options),
       "mysql",
       options?.onQuery
     );
   }
+  checkServerDriver("postgresql", options?.driver);
   return new AsyncEngine(
     createPostgresDriver(parsed.raw, options),
     "postgresql",
@@ -3081,6 +3177,7 @@ exports.AsyncResult = AsyncResult;
 exports.AsyncSession = AsyncSession;
 exports.BaseDialect = BaseDialect;
 exports.BaseRepository = BaseRepository;
+exports.BetterSqliteDriver = BetterSqliteDriver;
 exports.Column = Column;
 exports.DeleteBuilder = DeleteBuilder;
 exports.Expression = Expression;