@crvouga/sqlite-mem 0.2.0 → 1.0.0

package/dist/index.js

@@ -2,18 +2,21 @@
 var SqliteError = class extends Error {
   /** Coarse error class (constraint vs syntax vs missing object, …). */
   category;
-  /** Optional SQLite result-code name such as `SQLITE_CONSTRAINT`. */
+  /** SQLite result-code name such as `SQLITE_CONSTRAINT_UNIQUE`. */
   sqliteCode;
+  /** Same value as {@link sqliteCode} (Node `err.code` convention). */
+  code;
   /**
    * @param message - Human-readable error text.
    * @param category - Coarse class; defaults to `"other"`.
-   * @param sqliteCode - Optional SQLite result-code name.
+   * @param sqliteCode - SQLite result-code name; defaults to `"SQLITE_ERROR"`.
    */
-  constructor(message, category = "other", sqliteCode) {
+  constructor(message, category = "other", sqliteCode = "SQLITE_ERROR") {
     super(message);
     this.name = "SqliteError";
     this.category = category;
     this.sqliteCode = sqliteCode;
+    this.code = sqliteCode;
   }
 };
 var TriggerRaiseError = class extends SqliteError {
@@ -2396,17 +2399,6 @@ var Prng = class _Prng {
     return copy;
   }
 };
-function deriveSeed(...parts) {
-  let hash = 2166136261;
-  for (const part of parts) {
-    const text2 = String(part);
-    for (let i = 0; i < text2.length; i++) {
-      hash ^= text2.charCodeAt(i);
-      hash = Math.imul(hash, 16777619);
-    }
-  }
-  return hash | 0;
-}
 
 // src/types/value.ts
 var SqlReal = class {
@@ -8733,7 +8725,7 @@ function decodeDatabaseState(snapshot) {
     throw new SqliteError("invalid sqlite-mem snapshot magic", "other");
   const version = reader.u32();
   if (version !== VERSION && version !== VERSION_V1) {
-    throw new SqliteError(`unsupported sqlite-mem snapshot version: ${version}`, "unsupported");
+    throw new SqliteError(`unsupported sqlite-mem snapshot version: ${version}`, "snapshot_version", "SQLITE_FORMAT");
   }
   const state = new DatabaseState();
   state.foreignKeysEnabled = reader.u8() !== 0;
@@ -8989,16 +8981,14 @@ var ExecutionEnv = class {
   }
   getBoundParameter(name) {
     if (typeof name === "number") {
-      if (name < 1 || name > this.positional.length)
-        throw new SqliteError(`binding parameter ${name} is not supplied`, "misuse");
+      if (name < 1 || name > this.positional.length) return null;
       return this.positional[name - 1];
     }
     const key = name.toLowerCase();
-    const value = this.named.get(key);
-    if (value === void 0 && !this.named.has(key)) {
-      throw new SqliteError(`binding parameter :${name} is not supplied`, "misuse");
+    if (!this.named.has(key)) {
+      return null;
     }
-    return value ?? null;
+    return this.named.get(key) ?? null;
   }
   setNamed(name, value) {
     this.named.set(name.toLowerCase(), toSqlValue(value));
@@ -9086,7 +9076,7 @@ var ExecutionEnv = class {
         const result = this.selectRunner(select, this, context);
         return {
           columns: result.columns,
-          rows: result.values?.map((row2) => [...row2]) ?? result.rows.map((record) => result.columns.map((column) => record[column] ?? null))
+          rows: result.values.length > 0 ? result.values.map((row2) => [...row2]) : result.rows.map((record) => result.columns.map((column) => record[column] ?? null))
         };
       },
       matchFts: (table, column, query) => {
@@ -9114,14 +9104,29 @@ function toSqlValue(value) {
   }
   if (typeof value === "boolean") return value ? 1 : 0;
   if (value instanceof SqlReal || value instanceof SqlJsonText) return value;
-  if (value instanceof Uint8Array) return new Uint8Array(value);
+  if (value instanceof Uint8Array) {
+    if (isSharedArrayBufferView(value)) {
+      throw new SqliteError("cannot bind SharedArrayBuffer-backed buffers; copy into a Uint8Array first", "misuse");
+    }
+    return new Uint8Array(value);
+  }
   if (value instanceof ArrayBuffer) return new Uint8Array(value);
+  if (typeof SharedArrayBuffer !== "undefined" && value instanceof SharedArrayBuffer) {
+    throw new SqliteError("cannot bind SharedArrayBuffer; copy into an ArrayBuffer or Uint8Array first", "misuse");
+  }
+  if (ArrayBuffer.isView(value)) {
+    const kind = Object.prototype.toString.call(value).slice(8, -1);
+    throw new SqliteError(`cannot bind ${kind}; only Uint8Array and ArrayBuffer are accepted as BLOB values`, "misuse");
+  }
   throw new SqliteError(`unsupported bind value: ${typeof value}`, "datatype_mismatch");
 }
+function isSharedArrayBufferView(view) {
+  return typeof SharedArrayBuffer !== "undefined" && view.buffer instanceof SharedArrayBuffer;
+}
 
 // src/executor/result.ts
 function emptyResult(changes = 0, lastInsertRowid = 0) {
-  return { columns: [], rows: [], changes, lastInsertRowid };
+  return { columns: [], rows: [], values: [], changes, lastInsertRowid };
 }
 function exportSqlValue(value) {
   if (isSqlReal(value)) return value.value;
@@ -9133,7 +9138,7 @@ function valuesToResult(columns, values, changes = 0, lastInsertRowid = 0, optio
   const keepValues = options?.keepValues !== false;
   return {
     columns,
-    values: keepValues ? values.map((row) => row.map(exportSqlValue)) : void 0,
+    values: keepValues ? values.map((row) => row.map(exportSqlValue)) : [],
     rows: named ? values.map((row) => {
       const object = {};
       for (let index = 0; index < columns.length; index++) {
@@ -9146,7 +9151,10 @@ function valuesToResult(columns, values, changes = 0, lastInsertRowid = 0, optio
   };
 }
 function resultValues(result) {
-  return result.values?.map((row) => [...row]) ?? result.rows.map((row) => result.columns.map((column) => row[column] ?? null));
+  if (result.values.length > 0 || result.rows.length === 0) {
+    return result.values.map((row) => [...row]);
+  }
+  return result.rows.map((row) => result.columns.map((column) => row[column] ?? null));
 }
 
 // src/executor/attach.ts
@@ -12637,50 +12645,37 @@ var Statement = class _Statement {
   }
   database;
   sql;
-  bound = [];
   namedPlan = null;
   env = null;
   statements;
   schemaVersion;
   /**
-   * Construct a {@link Statement} for {@link Database.prepare}.
+   * Construct a {@link Statement} for {@link Database.prepare} / {@link Database.exec}.
    * @internal
    */
   static create(database, sql, statements) {
     return new _Statement(database, sql, statements);
   }
-  /**
-   * Store parameters for later {@link run} / {@link all} / {@link get} / {@link result}.
-   *
-   * Supports positional `?` / `?NNN` and named `:name` / `@name` / `$name` placeholders.
-   *
-   * @param params - Values to bind, in placeholder order.
-   * @returns `this` for chaining.
-   */
-  bind(...params) {
-    this.bound = [...params];
-    return this;
-  }
   /**
    * Execute for side effects (INSERT / UPDATE / DELETE / DDL).
    *
-   * @param params - If provided, override the last {@link bind}; otherwise bound values are used.
+   * @param params - Bind values for this call only.
    * @returns Mutation counters for this execution.
    * @throws {SqliteError} If the database is closed, the statement is empty, or execution fails.
    */
   run(...params) {
-    const result = this.execute(params.length > 0 ? params : this.bound, { named: false });
+    const result = this.execute(params, { named: false });
     return { changes: result.changes, lastInsertRowid: result.lastInsertRowid };
   }
   /**
    * Execute and return every result row as an object keyed by column name.
    *
    * @typeParam T - Row shape. Defaults to {@link QueryRow}.
-   * @param params - If provided, override the last {@link bind}; otherwise bound values are used.
+   * @param params - Bind values for this call only.
    * @throws {SqliteError} If the database is closed, the statement is empty, or execution fails.
    */
   all(...params) {
-    return this.execute(params.length > 0 ? params : this.bound, { named: true }).rows;
+    return this.execute(params, { named: true }).rows;
   }
   /**
    * Execute and return the full {@link ResultSet}, including column names.
@@ -12688,38 +12683,41 @@ var Statement = class _Statement {
    * Use this when you need metadata for an empty result (column names with zero rows).
    * {@link all} only returns row objects.
    *
-   * @param params - If provided, override the last {@link bind}; otherwise bound values are used.
+   * @param params - Bind values for this call only.
    * @throws {SqliteError} If the database is closed, the statement is empty, or execution fails.
    */
   result(...params) {
-    return this.execute(params.length > 0 ? params : this.bound, { named: true });
+    return this.execute(params, { named: true });
   }
   /**
    * Execute and return the first row, or `undefined` if there are no rows.
    *
    * @typeParam T - Row shape. Defaults to {@link QueryRow}.
-   * @param params - If provided, override the last {@link bind}; otherwise bound values are used.
+   * @param params - Bind values for this call only.
    * @throws {SqliteError} If the database is closed, the statement is empty, or execution fails.
    */
   get(...params) {
-    return this.execute(params.length > 0 ? params : this.bound, { named: true, maxRows: 1 }).rows[0];
+    return this.execute(params, { named: true, maxRows: 1 }).rows[0];
   }
   execute(params, options) {
     this.database.assertOpen();
     this.reprepareIfSchemaChanged();
     if (this.statements.length === 0) throw new SqliteError("empty statement", "misuse");
+    this.namedPlan ??= planNamedParameters(this.sql);
+    const expected = this.namedPlan.expectedCount;
+    if (params.length > 0 && params.length !== expected) {
+      throw new SqliteError(`SQLite query expected ${expected} values, received ${params.length}`, "misuse");
+    }
     const env = this.obtainEnv(params);
     env.maxRows = options?.maxRows ?? Number.POSITIVE_INFINITY;
     env.includeNamedRows = options?.named !== false;
     env.includeValues = true;
     this.bindNamed(env, params);
     let result;
-    let lastQuery;
     for (const statement of this.statements) {
       result = executeStatement(statement, env);
-      if (result.columns.length > 0) lastQuery = result;
     }
-    return lastQuery ?? result;
+    return result;
   }
   obtainEnv(params) {
     if (this.env) {
@@ -12769,18 +12767,18 @@ function planNamedParameters(sql) {
       }
     }
   }
-  return { named };
+  return { named, expectedCount: nextSlot - 1 };
 }
 
 // src/api/database.ts
 var Database = class {
   /** @internal Engine catalog, tables, and mutation counters. */
   state = new DatabaseState();
-  /** Seed used to construct the PRNG when `options.prng` is omitted. */
+  /** Seed used to construct the PRNG. */
   seed;
   /**
    * PRNG backing `random()` / `randomblob()` and related builtins.
-   * Prefer passing `seed` or `prng` to the constructor.
+   * Prefer passing `seed` to the constructor.
    * @internal
    */
   prng;
@@ -12794,6 +12792,8 @@ var Database = class {
   transactions;
   closed = false;
   transactionSequence = 0;
+  /** Depth of active {@link transaction} callbacks (not SQL BEGIN). */
+  apiTransactionDepth = 0;
   /**
    * Create an empty in-memory database.
    *
@@ -12801,49 +12801,53 @@ var Database = class {
    */
   constructor(options = {}) {
     this.seed = options.seed ?? DEFAULT_DATABASE_SEED;
-    this.prng = options.prng ?? new Prng(this.seed);
+    this.prng = new Prng(this.seed);
     this.now = resolveClock(options.now);
     this.transactions = new TransactionManager(this.state, this.prng);
   }
   /**
    * Execute SQL for its side effects (DDL/DML). Multiple statements are allowed.
    *
+   * Does not accept bind parameters — use {@link prepare} or {@link query}.
+   *
    * @param sql - SQL to run (semicolon-separated statements are ok).
-   * @param params - Bound parameters for `?` / `:name` placeholders.
-   * @throws {SqliteError} If the database is closed or the SQL fails.
+   * @throws {SqliteError} If the database is closed, extra arguments are passed, or the SQL fails.
    */
-  exec(sql, params = []) {
+  exec(sql) {
     this.assertOpen();
-    Statement.create(this, sql, parse(sql)).run(...params);
+    if (arguments.length > 1) {
+      throw new SqliteError("exec() does not accept parameters; use prepare() or query()", "misuse");
+    }
+    Statement.create(this, sql, parse(sql)).run();
   }
   /**
-   * Execute a query and return all rows as objects keyed by column name.
+   * Execute a single-statement query and return all rows as objects keyed by column name.
    *
    * @typeParam T - Row shape. Defaults to {@link QueryRow}.
-   * @param sql - SQL SELECT (or any statement that produces a result set).
+   * @param sql - A single SQL statement (trailing `;` is fine).
    * @param params - Bound parameters for `?` / `:name` placeholders.
    * @returns All result rows.
-   * @throws {SqliteError} If the database is closed or the SQL fails.
+   * @throws {SqliteError} If the database is closed, `sql` is not a single statement, or execution fails.
    */
   query(sql, params = []) {
     this.assertOpen();
-    return Statement.create(this, sql, parse(sql)).all(...params);
+    return this.prepareSingle(sql).all(...params);
   }
   /**
-   * Compile `sql` into a reusable {@link Statement}.
+   * Compile a single SQL statement into a reusable {@link Statement}.
    *
-   * @param sql - SQL to prepare.
-   * @throws {SqliteError} If the database is closed or `sql` cannot be parsed.
+   * @param sql - A single SQL statement (trailing `;` is fine). Multi-statement scripts are rejected.
+   * @throws {SqliteError} If the database is closed or `sql` cannot be prepared as one statement.
    */
   prepare(sql) {
     this.assertOpen();
-    return Statement.create(this, sql, parse(sql));
+    return this.prepareSingle(sql);
   }
   /**
    * Run `fn` inside a transaction. Commits on success; rolls back if `fn` throws.
    *
    * Nested calls use SAVEPOINTs so an inner failure does not abort the outer
-   * transaction.
+   * transaction. Calling {@link close} from inside `fn` throws `misuse`.
    *
    * @param fn - Work to run while the transaction is open.
    * @returns The value returned by `fn`.
@@ -12851,27 +12855,32 @@ var Database = class {
    */
   transaction(fn) {
     this.assertOpen();
-    if (!this.transactions.inTransaction) {
-      this.transactions.begin();
+    this.apiTransactionDepth++;
+    try {
+      if (!this.transactions.inTransaction) {
+        this.transactions.begin();
+        try {
+          const value = fn();
+          this.transactions.commit();
+          return value;
+        } catch (error) {
+          this.transactions.rollback();
+          throw error;
+        }
+      }
+      const name = `__api_transaction_${++this.transactionSequence}`;
+      this.transactions.savepoint(name);
       try {
         const value = fn();
-        this.transactions.commit();
+        this.transactions.release(name);
         return value;
       } catch (error) {
-        this.transactions.rollback();
+        this.transactions.rollback(name);
+        this.transactions.release(name);
         throw error;
       }
-    }
-    const name = `__api_transaction_${++this.transactionSequence}`;
-    this.transactions.savepoint(name);
-    try {
-      const value = fn();
-      this.transactions.release(name);
-      return value;
-    } catch (error) {
-      this.transactions.rollback(name);
-      this.transactions.release(name);
-      throw error;
+    } finally {
+      this.apiTransactionDepth--;
     }
   }
   /**
@@ -12892,6 +12901,8 @@ var Database = class {
    * Replace this database's contents with a blob from {@link snapshot}.
    *
    * Restores PRNG state and the clock when the snapshot includes them (v2).
+   * Newer library versions can restore older snapshots; older libraries cannot
+   * restore newer format versions.
    *
    * @param snapshot - Bytes previously returned by {@link snapshot}.
    * @throws {SqliteError} If the database is closed, a transaction is open, or the blob is invalid.
@@ -12910,10 +12921,14 @@ var Database = class {
   /**
    * Close the database. Further SQL throws {@link SqliteError}. Idempotent.
    *
-   * Rolls back an open transaction, if any.
+   * Rolls back an open SQL transaction, if any. Throws if called from inside
+   * a {@link transaction} callback.
    */
   close() {
     if (this.closed) return;
+    if (this.apiTransactionDepth > 0) {
+      throw new SqliteError("cannot close database inside transaction()", "misuse");
+    }
     if (this.transactions.inTransaction) this.transactions.rollback();
     this.closed = true;
   }
@@ -12943,42 +12958,30 @@ var Database = class {
   assertOpen() {
     if (this.closed) throw new SqliteError("Database is closed", "misuse");
   }
+  prepareSingle(sql) {
+    const statements = parse(sql);
+    if (statements.length === 0) {
+      throw new SqliteError("empty statement", "misuse");
+    }
+    if (statements.length > 1) {
+      throw new SqliteError("query()/prepare() accept a single statement only; use exec() for scripts", "misuse");
+    }
+    return Statement.create(this, sql, statements);
+  }
 };
+var disposeKey = Symbol.dispose;
+if (typeof disposeKey === "symbol") {
+  Object.defineProperty(Database.prototype, disposeKey, {
+    value: function() {
+      this.close();
+    },
+    writable: true,
+    configurable: true
+  });
+}
 export {
-  DEFAULT_DATABASE_SEED,
-  DEFAULT_NOW,
   Database,
-  Prng,
-  SqlJsonText,
-  SqlReal,
   SqliteError,
-  Statement,
-  affinityFromTypeName,
-  applyAffinity,
-  asSqlJsonText,
-  asSqlReal,
-  canonicalizeNumber,
-  cloneSqlValue,
-  coerceToNumber,
-  compareSql,
-  decodeDatabaseState,
-  deriveSeed,
-  encodeDatabaseState,
-  evalExpr,
-  fixedClock,
-  globMatch,
-  isSqlJsonText,
-  isSqlReal,
-  isTruthySql,
-  likeMatch,
-  parse,
-  resolveClock,
-  sqlValueEquals,
-  storageClassOf,
-  toInteger,
-  tokenize,
-  typeofSql,
-  utf8Decode,
-  utf8Encode
+  Statement
 };
 //# sourceMappingURL=index.js.map