@photostructure/sqlite 0.4.0 → 1.0.0

package/CHANGELOG.md

@@ -2,7 +2,34 @@
 
 All notable changes to this project will be documented in this file.
 
-## [0.4.0] - to be released
+## [1.0.0] (2026-03-07)
+
+Promotion to v1.0.0 following API stabilization and 0.5.0 release.
+
+API compatible with `node:sqlite` from Node.js v25.8.1.
+
+### Added
+
+- **`db.limits` property**: Get and set SQLite limits (length, sqlLength, column, exprDepth, compoundSelect, vdbeOp, functionArg, attach, likePatternLength, variableNumber, triggerDepth) at runtime. Supports `Infinity` to reset to compile-time maximum. Also accepts `limits` option in `DatabaseSync` constructor.
+- **Statement iterator invalidation**: Calling `stmt.run()`, `stmt.get()`, `stmt.all()`, or `stmt.iterate()` now invalidates any active iterator on the same statement, throwing `ERR_INVALID_STATE`
+
+### Changed
+
+- **SQLite 3.52.0**: Updated from 3.51.2
+
+## [0.5.0] (2026-02-06)
+
+### Added
+
+- **Statement modes via `enhance()`**: `stmt.pluck()`, `stmt.raw()`, `stmt.expand()` for better-sqlite3 compatibility
+  - `.pluck()` returns only the first column value from queries
+  - `.raw()` returns rows as arrays instead of objects
+  - `.expand()` returns rows namespaced by table, correctly handling duplicate column names across JOINs
+  - All three modes are mutually exclusive, matching better-sqlite3's toggle semantics
+- **`stmt.database`**: Back-reference from prepared statements to their parent database instance
+- **`EnhancedStatementMethods` type**: TypeScript interface for `pluck()`, `raw()`, `expand()`, and `database`
+
+## [0.4.0] (2026-02-04)
 
 API compatible with `node:sqlite` from Node.js v25.6.1.
 
@@ -118,6 +145,8 @@ API compatible with `node:sqlite` from Node.js v25.6.1.
 - macOS (x64, ARM64)
 - Linux (x64, ARM64), (glibc 2.28+, musl)
 
+[1.0.0]: https://github.com/PhotoStructure/node-sqlite/releases/tag/v1.0.0
+[0.5.0]: https://github.com/PhotoStructure/node-sqlite/releases/tag/v0.5.0
 [0.4.0]: https://github.com/PhotoStructure/node-sqlite/releases/tag/v0.4.0
 [0.3.0]: https://github.com/PhotoStructure/node-sqlite/releases/tag/v0.3.0
 [0.2.1]: https://github.com/PhotoStructure/node-sqlite/releases/tag/v0.2.1

package/README.md

@@ -1,9 +1,11 @@
+<img src="https://raw.githubusercontent.com/photostructure/node-sqlite/main/doc/logo.svg" alt="PhotoStructure SQLite logo" width="200">
+
 # @photostructure/sqlite
 
 [![npm version](https://img.shields.io/npm/v/@photostructure/sqlite.svg)](https://www.npmjs.com/package/@photostructure/sqlite)
 [![CI](https://github.com/photostructure/node-sqlite/actions/workflows/build.yml/badge.svg)](https://github.com/photostructure/node-sqlite/actions/workflows/build.yml)
 
-Native SQLite for Node.js 20+ without the experimental flag. Drop-in replacement for `node:sqlite`. Synced with Node.js v25.6.1 for the latest features including native `Symbol.dispose` resource management.
+Native SQLite for Node.js 20+. Drop-in replacement for `node:sqlite`. Synced with Node.js v25.8.1 for the latest features including native `Symbol.dispose` resource management.
 
 ## Installation
 
@@ -27,7 +29,7 @@ db.close();
 
 ## Features
 
-- 100% compatible with Node.js v25.6.1 built-in `node:sqlite` module\*
+- 100% compatible with Node.js v25.8.1 built-in `node:sqlite` module\*
 - Zero dependencies - native SQLite implementation
 - Synchronous API - no async overhead
 - Performance comparable to better-sqlite3
@@ -70,12 +72,6 @@ db.close();
 - [Build Flags & Configuration](./doc/build-flags.md)
 - [Library Comparison](./doc/library-comparison.md)
 
-## Support
-
-- 🐛 [Issues](https://github.com/photostructure/node-sqlite/issues)
-- 💬 [Discussions](https://github.com/photostructure/node-sqlite/discussions)
-- 📧 [Security](./SECURITY.md)
-
 ## License
 
 MIT - see [LICENSE](./LICENSE) for details.

package/binding.gyp

@@ -87,6 +87,7 @@
                   ],
                   "msvs_settings": {
                     "VCCLCompilerTool": {
+                      "WarningLevel": 4,
                       "AdditionalOptions": [
                         "/Qspectre",
                         "/guard:cf",
@@ -115,6 +116,7 @@
                   ],
                   "msvs_settings": {
                     "VCCLCompilerTool": {
+                      "WarningLevel": 4,
                       "AdditionalOptions": [
                         "/guard:cf",
                         "/ZH:SHA_256",

package/dist/index.cjs

@@ -352,6 +352,148 @@ function getBeginStatement(mode) {
 }
 
 // src/enhance.ts
+var ENHANCED_PREPARE = /* @__PURE__ */ Symbol.for("@photostructure/sqlite:enhancedPrepare");
+function extractFirstColumn(row) {
+  if (row == null) return row;
+  if (Array.isArray(row)) return row[0];
+  const keys = Object.keys(row);
+  return keys.length > 0 ? row[keys[0]] : void 0;
+}
+function buildColumnTableMap(stmt) {
+  if (typeof stmt.columns !== "function") return void 0;
+  const cols = stmt.columns();
+  return cols.map((c) => ({
+    table: c.table ?? "$",
+    column: c.name
+  }));
+}
+function expandRowFromArray(row, columnMap) {
+  const result = {};
+  for (let i = 0; i < columnMap.length && i < row.length; i++) {
+    const { table, column } = columnMap[i];
+    result[table] ??= {};
+    result[table][column] = row[i];
+  }
+  return result;
+}
+function expandRowFromObject(row, columnMap) {
+  const result = {};
+  const keys = Object.keys(row);
+  for (let i = 0; i < keys.length && i < columnMap.length; i++) {
+    const { table, column } = columnMap[i];
+    result[table] ??= {};
+    result[table][column] = row[keys[i]];
+  }
+  return result;
+}
+function validateToggle(value) {
+  const use = value === void 0 ? true : value;
+  if (typeof use !== "boolean") {
+    throw new TypeError("Expected first argument to be a boolean");
+  }
+  return use;
+}
+function transformRow(row, mode, columnMap) {
+  if (row == null || mode === "flat") return row;
+  if (mode === "pluck") return extractFirstColumn(row);
+  if (mode === "expand") {
+    if (Array.isArray(row)) {
+      return expandRowFromArray(row, columnMap);
+    }
+    return expandRowFromObject(row, columnMap);
+  }
+  return row;
+}
+function enhanceStatement(stmt) {
+  if (typeof stmt.pluck === "function") {
+    return stmt;
+  }
+  let mode = "flat";
+  let columnMap;
+  const originalGet = typeof stmt.get === "function" ? stmt.get.bind(stmt) : void 0;
+  const originalAll = stmt.all.bind(stmt);
+  const originalIterate = typeof stmt.iterate === "function" ? stmt.iterate.bind(stmt) : void 0;
+  function setMode(target, use) {
+    if (use) {
+      mode = target;
+      if (target === "expand" && columnMap == null) {
+        columnMap = buildColumnTableMap(stmt);
+        if (columnMap == null) {
+          throw new TypeError(
+            "expand() requires the statement to have a columns() method"
+          );
+        }
+      }
+    } else if (mode === target) {
+      mode = "flat";
+    }
+    if (typeof stmt.setReturnArrays === "function") {
+      stmt.setReturnArrays(mode === "raw" || mode === "expand");
+    }
+  }
+  Object.defineProperty(stmt, "pluck", {
+    value: function pluck(toggle) {
+      setMode("pluck", validateToggle(toggle));
+      return stmt;
+    },
+    writable: true,
+    configurable: true,
+    enumerable: false
+  });
+  Object.defineProperty(stmt, "raw", {
+    value: function raw(toggle) {
+      setMode("raw", validateToggle(toggle));
+      return stmt;
+    },
+    writable: true,
+    configurable: true,
+    enumerable: false
+  });
+  Object.defineProperty(stmt, "expand", {
+    value: function expand(toggle) {
+      setMode("expand", validateToggle(toggle));
+      return stmt;
+    },
+    writable: true,
+    configurable: true,
+    enumerable: false
+  });
+  if (originalGet != null) {
+    Object.defineProperty(stmt, "get", {
+      value: (...params) => {
+        const row = originalGet(...params);
+        return transformRow(row, mode, columnMap);
+      },
+      writable: true,
+      configurable: true,
+      enumerable: false
+    });
+  }
+  Object.defineProperty(stmt, "all", {
+    value: (...params) => {
+      const rows = originalAll(...params);
+      if (mode === "flat" || mode === "raw") return rows;
+      return rows.map((row) => transformRow(row, mode, columnMap));
+    },
+    writable: true,
+    configurable: true,
+    enumerable: false
+  });
+  if (originalIterate != null) {
+    Object.defineProperty(stmt, "iterate", {
+      value: function* (...params) {
+        const iter = originalIterate(...params);
+        for (const row of iter) {
+          yield transformRow(row, mode, columnMap);
+        }
+      },
+      writable: true,
+      configurable: true,
+      enumerable: false
+    });
+  }
+  return stmt;
+}
 function pragmaImpl(source, options) {
   if (typeof source !== "string") {
     throw new TypeError("Expected first argument to be a string");
@@ -364,20 +506,10 @@ function pragmaImpl(source, options) {
     throw new TypeError('Expected the "simple" option to be a boolean');
   }
   const stmt = this.prepare(`PRAGMA ${source}`);
-  const rows = stmt.all();
   if (simple) {
-    const firstRow = rows[0];
-    if (firstRow == null) {
-      return void 0;
-    }
-    const keys = Object.keys(firstRow);
-    const firstKey = keys[0];
-    if (firstKey == null) {
-      return void 0;
-    }
-    return firstRow[firstKey];
+    return extractFirstColumn(stmt.all()[0]);
   }
-  return rows;
+  return stmt.all();
 }
 function transactionImpl(fn) {
   return createTransaction(this, fn);
@@ -386,21 +518,45 @@ function hasEnhancedMethods(db) {
   return typeof db.pragma === "function" && typeof db.transaction === "function";
 }
 function enhance(db) {
-  if (hasEnhancedMethods(db)) {
-    return db;
+  if (!hasEnhancedMethods(db)) {
+    Object.defineProperty(db, "pragma", {
+      value: pragmaImpl,
+      writable: true,
+      configurable: true,
+      enumerable: false
+    });
+    Object.defineProperty(db, "transaction", {
+      value: transactionImpl,
+      writable: true,
+      configurable: true,
+      enumerable: false
+    });
+  }
+  if (!db[ENHANCED_PREPARE]) {
+    const originalPrepare = db.prepare.bind(db);
+    Object.defineProperty(db, "prepare", {
+      value: (...args) => {
+        const stmt = originalPrepare(...args);
+        enhanceStatement(stmt);
+        Object.defineProperty(stmt, "database", {
+          value: db,
+          writable: false,
+          configurable: true,
+          enumerable: false
+        });
+        return stmt;
+      },
+      writable: true,
+      configurable: true,
+      enumerable: false
+    });
+    Object.defineProperty(db, ENHANCED_PREPARE, {
+      value: true,
+      writable: false,
+      configurable: false,
+      enumerable: false
+    });
   }
-  Object.defineProperty(db, "pragma", {
-    value: pragmaImpl,
-    writable: true,
-    configurable: true,
-    enumerable: false
-  });
-  Object.defineProperty(db, "transaction", {
-    value: transactionImpl,
-    writable: true,
-    configurable: true,
-    enumerable: false
-  });
   return db;
 }
 function isEnhanced(db) {
@@ -423,6 +579,71 @@ DatabaseSync.prototype = _DatabaseSync.prototype;
 DatabaseSync.prototype.createTagStore = function(capacity) {
   return new SQLTagStore(this, capacity);
 };
+var LIMIT_MAPPING = [
+  { name: "length", id: 0 },
+  { name: "sqlLength", id: 1 },
+  { name: "column", id: 2 },
+  { name: "exprDepth", id: 3 },
+  { name: "compoundSelect", id: 4 },
+  { name: "vdbeOp", id: 5 },
+  { name: "functionArg", id: 6 },
+  { name: "attach", id: 7 },
+  { name: "likePatternLength", id: 8 },
+  { name: "variableNumber", id: 9 },
+  { name: "triggerDepth", id: 10 }
+];
+var INT_MAX = 2147483647;
+var limitsCache = /* @__PURE__ */ new WeakMap();
+function validateLimitValue(value) {
+  if (typeof value !== "number" || Number.isNaN(value)) {
+    throw new TypeError(
+      "Limit value must be a non-negative integer or Infinity."
+    );
+  }
+  if (value === Infinity) {
+    return INT_MAX;
+  }
+  if (!Number.isFinite(value) || value !== Math.trunc(value)) {
+    throw new TypeError(
+      "Limit value must be a non-negative integer or Infinity."
+    );
+  }
+  if (value < 0) {
+    throw new RangeError("Limit value must be non-negative.");
+  }
+  return value;
+}
+function createLimitsObject(db) {
+  const obj = /* @__PURE__ */ Object.create(null);
+  for (const { name, id } of LIMIT_MAPPING) {
+    Object.defineProperty(obj, name, {
+      get() {
+        return db.getLimit(id);
+      },
+      set(value) {
+        const validated = validateLimitValue(value);
+        db.setLimit(id, validated);
+      },
+      enumerable: true,
+      configurable: false
+    });
+  }
+  return obj;
+}
+if (!Object.getOwnPropertyDescriptor(DatabaseSync.prototype, "limits")) {
+  Object.defineProperty(DatabaseSync.prototype, "limits", {
+    get() {
+      let obj = limitsCache.get(this);
+      if (obj == null) {
+        obj = createLimitsObject(this);
+        limitsCache.set(this, obj);
+      }
+      return obj;
+    },
+    enumerable: true,
+    configurable: true
+  });
+}
 var _StatementSync = binding.StatementSync;
 var StatementSync = function StatementSync2() {
   const err = new TypeError("Illegal constructor");