@jarenjs/db 0.87.0 → 0.89.0

package/src/drivers/file-identity.js

@@ -0,0 +1,14 @@
+//@ts-check
+/** Native filesystem identity stays below the Node/Bun entry points. */
+import { chain } from '../driver.js';
+import { sqliteDatabasePath } from '../migration-target.js';
+
+/** Device/inode identity also catches hardlinks that SQLite filenames cannot.
+ * The filesystem is imported only when identifying an opened file; two private
+ * in-memory databases remain independent.
+ * @param {any} connection @returns {any} value-or-promise of string or null */
+export function nativeDatabaseIdentity(connection) {
+  return chain(sqliteDatabasePath(connection), (path) => path === null ? null
+    : import('node:fs/promises').then((fs) => fs.stat(path, { bigint: true }))
+      .then((stat) => `${stat.dev}:${stat.ino}`));
+}

package/src/drivers/node.js

@@ -9,6 +9,7 @@
 import { lazyOpen, openConnection } from '../driver.js';
 import { sqliteDialect } from '../dialects/sqlite.js';
 import { PRAGMA_NAMES } from '../pragmas.js';
+import { nativeDatabaseIdentity } from './file-identity.js';
 
 /**
  * Adapt an already-constructed `node:sqlite` `DatabaseSync` (or any
@@ -109,6 +110,7 @@ export function nodeDriver() {
   return Object.freeze({
     name: 'node-sqlite',
     dialect: sqliteDialect,
+    databaseIdentity: nativeDatabaseIdentity,
     /**
      * @param {string} path
      * @param {{ timeout?: number, readOnly?: boolean,

package/src/foreign-key-scope.js

@@ -0,0 +1,50 @@
+//@ts-check
+/** SQLite's connection settings belong outside the transaction they govern. */
+import { isThenable } from '@jarenjs/core/function';
+import { chain } from './driver.js';
+import { DbCompileError } from './errors.js';
+
+/** Suspend enforcement and legacy rewrites for a caller-owned transaction,
+ * restoring the exact original settings after success or failure. The caller
+ * still must run foreign_key_check before committing. Value-or-promise, so both
+ * synchronous table helpers and asynchronous migration drivers share one bracket.
+ * @param {any} connection @param {()=>any} fn @returns {any} */
+export function withForeignKeySettings(connection, fn) {
+  const dialect = connection.dialect;
+  const read = (name) => chain(connection.prepare(dialect.introspect.pragma(name)), (s) => chain(s.get([]), (row) => row[name]));
+  return chain(read('foreign_keys'), (foreignKeys) => chain(read('legacy_alter_table'), (legacy) => {
+    const restore = () => {
+      const errors = [];
+      const attempt = (sql) => {
+        try {
+          const result = connection.exec(sql);
+          return isThenable(result) ? result.then(() => undefined, (error) => { errors.push(error); }) : undefined;
+        }
+        catch (error) { errors.push(error); return undefined; }
+      };
+      // These settings are independent: a failed legacy restoration must
+      // not prevent the attempt to re-enable foreign-key enforcement.
+      return chain(attempt(dialect.pragma.set('legacy_alter_table', legacy ? 'ON' : 'OFF')),
+        () => chain(attempt(dialect.pragma.foreignKeys(!!foreignKeys)), () => errors));
+    };
+    const finish = (value) => chain(restore(), (errors) => {
+      if (errors.length === 1) throw errors[0];
+      if (errors.length > 1) throw new AggregateError(errors, 'migration connection settings could not be restored');
+      return value;
+    });
+    const fail = (error) => chain(restore(), (errors) => {
+      if (errors.length > 0) throw new AggregateError([error, ...errors],
+        'migration failed and its connection settings could not be restored', { cause: error });
+      throw error;
+    });
+    let result;
+    try {
+      result = chain(connection.exec(dialect.pragma.foreignKeys(false)), () => chain(read('foreign_keys'), (actual) => {
+        if (actual !== 0) throw new DbCompileError('JD0021', 'foreign_keys cannot change inside a transaction; establish the outer migration scope first');
+        return chain(connection.exec(dialect.pragma.set('legacy_alter_table', 'ON')), fn);
+      }));
+    }
+    catch (error) { return fail(error); }
+    return isThenable(result) ? result.then(finish, fail) : finish(result);
+  }));
+}