tempest-db-js 0.6.0 → 0.8.0

package/dist/index.cjs

@@ -611,6 +611,21 @@ function assertWritableValues(model, values, clause) {
   }
   if (issues.length > 0) throw new ValidationError(model.tablename, issues);
 }
+function assertConsistentRows(model, rows) {
+  if (rows.length < 2) return;
+  const union = /* @__PURE__ */ new Set();
+  for (const row of rows) for (const key of Object.keys(row)) union.add(key);
+  const inconsistent = [...union].filter((key) => rows.some((row) => !(key in row)));
+  if (inconsistent.length === 0) return;
+  const columns = columnsOf(model);
+  const defaulted = inconsistent.filter((key) => columns[key]?.flags.hasDefault);
+  if (defaulted.length === 0) return;
+  const named = defaulted.map((c) => `"${c}"`).join(", ");
+  const verb = defaulted.length === 1 ? "has" : "have";
+  throw new ValidationError(model.tablename, [
+    `values: ${named} ${verb} a default but is missing from some rows of this multi-row insert \u2014 every row shares one column list, so the omitting rows would be written as NULL instead of taking the default. Give the column in every row, or insert the rows separately.`
+  ]);
+}
 function describeValue(value) {
   if (typeof value === "function") return "a function";
   if (Array.isArray(value)) return "an array";
@@ -633,11 +648,13 @@ var InsertBuilder = class _InsertBuilder {
    * @param rows One row, or an array of rows.
    * @returns A builder carrying the rows.
    * @throws ValidationError When a value is not a column value the dialect can
-   *   bind (see the `sql` helpers for writing an expression instead).
+   *   bind (see the `sql` helpers for writing an expression instead), or when the
+   *   rows of a multi-row insert disagree about a column that has a default.
    */
   values(rows) {
     const list = Array.isArray(rows) ? rows : [rows];
     for (const row of list) assertWritableValues(this.source, row, "values");
+    assertConsistentRows(this.source, list);
     return this.with({ values: list });
   }
   /**
@@ -939,6 +956,18 @@ var Params = class {
     return this.placeholder(this.values.length);
   }
 };
+function insertColumns(rows) {
+  const columns = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const row of rows) {
+    for (const key of Object.keys(row)) {
+      if (seen.has(key)) continue;
+      seen.add(key);
+      columns.push(key);
+    }
+  }
+  return columns;
+}
 function insertHasExpression(node) {
   for (const row of node.values) {
     for (const value of Object.values(row)) {
@@ -1168,7 +1197,7 @@ var BaseDialect = class _BaseDialect {
    * SQL order, so placeholder positions stay correct.
    */
   compileInsert(node, params) {
-    const columns = node.values.length > 0 ? Object.keys(node.values[0]) : [];
+    const columns = insertColumns(node.values);
     const conflict = node.onConflict;
     const cacheable = conflict?.targetWhere === void 0 && conflict?.updateWhere === void 0 && !insertHasExpression(node);
     if (!cacheable) return this.compileInsertDirect(node, columns, params);
@@ -1977,10 +2006,18 @@ var NodeSqliteDriver = class _NodeSqliteDriver {
   constructor(database) {
     this.db = database;
   }
-  /** Open a `node:sqlite` database at the given path (or `:memory:`). */
-  static open(path) {
+  /**
+   * Open a `node:sqlite` database at the given path (or `:memory:`).
+   *
+   * @param path The database file, or `":memory:"`.
+   * @param options Passed straight to `DatabaseSync` (`readOnly`, `timeout`, …).
+   * @returns A driver over the open handle.
+   */
+  static open(path, options) {
     const { DatabaseSync } = nodeRequire("node:sqlite");
-    return new _NodeSqliteDriver(new DatabaseSync(path));
+    return new _NodeSqliteDriver(
+      options ? new DatabaseSync(path, { ...options }) : new DatabaseSync(path)
+    );
   }
   /** Return the cached prepared statement for `sql`, preparing it on first use. */
   // biome-ignore lint/suspicious/noExplicitAny: statement type is unavailable here.
@@ -2010,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);
 }
@@ -2459,6 +2558,13 @@ var AsyncSession = class _AsyncSession {
     await this.close();
   }
 };
+function emitNotice(logger, notice) {
+  if (!logger) return;
+  try {
+    logger(notice);
+  } catch {
+  }
+}
 var SyncEngine = class {
   constructor(driver, logger) {
     this.driver = driver;
@@ -2526,8 +2632,43 @@ function asAsync(driver) {
     } : {}
   };
 }
-function openSqliteDriver(path, _options) {
-  return NodeSqliteDriver.open(path);
+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);
@@ -2536,29 +2677,28 @@ function createSyncEngine(url, options) {
       `createSyncEngine supports only SQLite; ${parsed.dialect} is async-only \u2014 use createEngine.`
     );
   }
-  return new SyncEngine(
-    openSqliteDriver(parsed.database ?? ":memory:"),
-    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:")),
+      asAsync(openSqliteDriver(parsed, options)),
       "sqlite",
       options?.onQuery
     );
   }
   if (parsed.dialect === "mysql") {
+    checkServerDriver("mysql", options?.driver);
     return new AsyncEngine(
-      createMysqlDriver(parsed.raw, options?.pool),
+      createMysqlDriver(parsed.raw, options),
       "mysql",
       options?.onQuery
     );
   }
+  checkServerDriver("postgresql", options?.driver);
   return new AsyncEngine(
-    createPostgresDriver(parsed.raw, options?.pool),
+    createPostgresDriver(parsed.raw, options),
     "postgresql",
     options?.onQuery
   );
@@ -2578,7 +2718,8 @@ function toMysqlResult(rows) {
   const header = rows;
   return { rows: [], changes: header.affectedRows ?? 0 };
 }
-function createMysqlDriver(url, pool) {
+function createMysqlDriver(url, options) {
+  const pool = options?.pool;
   let poolHandle;
   const ensure = async () => {
     if (poolHandle) return;
@@ -2591,6 +2732,7 @@ function createMysqlDriver(url, pool) {
     if (pool?.size !== void 0) opts.connectionLimit = pool.size;
     if (pool?.idleTimeoutMs !== void 0) opts.idleTimeout = pool.idleTimeoutMs;
     if (pool?.connectTimeoutMs !== void 0) opts.connectTimeout = pool.connectTimeoutMs;
+    Object.assign(opts, options?.driverOptions ?? {});
     poolHandle = mod.createPool(opts);
   };
   const runOn = async (queryable, sql2, params) => {
@@ -2624,7 +2766,8 @@ function toPostgresResult(rows) {
   const arr = rows;
   return { rows: Array.from(arr), changes: arr.count ?? arr.length };
 }
-function createPostgresDriver(url, pool) {
+function createPostgresDriver(url, options) {
+  const pool = options?.pool;
   let client;
   const ensure = async () => {
     if (client) return;
@@ -2640,6 +2783,8 @@ function createPostgresDriver(url, pool) {
     if (pool?.connectTimeoutMs !== void 0) {
       opts.connect_timeout = Math.ceil(pool.connectTimeoutMs / 1e3);
     }
+    opts.onnotice = (notice) => emitNotice(options?.onNotice, notice);
+    Object.assign(opts, options?.driverOptions ?? {});
     client = (mod.default ?? mod)(url, opts);
   };
   return {
@@ -3032,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;