@event-driven-io/dumbo 0.13.0-beta.21 → 0.13.0-beta.23

package/dist/{chunk-FC4JR2R3.js → chunk-56QRSCG5.js}

@@ -1,7 +1,7 @@
 import {
   SQL,
   exists
-} from "./chunk-XO5T5N5S.js";
+} from "./chunk-QUAG4MBP.js";
 
 // src/storage/postgresql/core/connections/connectionString.ts
 var defaultPostgreSQLConnectionString = "postgresql://postgres@localhost:5432/postgres";
@@ -80,4 +80,4 @@ export {
   functionExists,
   postgreSQLMetadata
 };
-//# sourceMappingURL=chunk-FC4JR2R3.js.map
+//# sourceMappingURL=chunk-56QRSCG5.js.map

package/dist/{chunk-65DKXURG.js → chunk-5OX6NE4Z.js}

@@ -28,7 +28,7 @@ import {
   registerDefaultMigratorOptions,
   registerFormatter,
   single
-} from "./chunk-XO5T5N5S.js";
+} from "./chunk-QUAG4MBP.js";
 
 // src/storage/postgresql/core/errors/errorMapper.ts
 var getPostgresErrorCode = (error) => {
@@ -478,4 +478,4 @@ export {
   pgFormatter,
   PostgreSQLDatabaseName
 };
-//# sourceMappingURL=chunk-65DKXURG.js.map
+//# sourceMappingURL=chunk-5OX6NE4Z.js.map

package/dist/{chunk-IVJ3SNPJ.js → chunk-5SCFH2HY.js}

@@ -1,7 +1,7 @@
 import {
   SQL,
   exists
-} from "./chunk-XO5T5N5S.js";
+} from "./chunk-QUAG4MBP.js";
 
 // src/storage/sqlite/core/schema/schema.ts
 var defaultSQLiteDatabase = ":memory:";
@@ -31,4 +31,4 @@ export {
   tableExists,
   sqliteMetadata
 };
-//# sourceMappingURL=chunk-IVJ3SNPJ.js.map
+//# sourceMappingURL=chunk-5SCFH2HY.js.map

package/dist/{chunk-AMACBMAZ.cjs → chunk-7D7WADBK.cjs}

@@ -28,7 +28,8 @@
 
 
 
-var _chunkXOQHZABKcjs = require('./chunk-XOQHZABK.cjs');
+
+var _chunkQVEVSWG6cjs = require('./chunk-QVEVSWG6.cjs');
 
 // src/storage/sqlite/core/errors/errorMapper.ts
 var getSqliteErrorCode = (error) => {
@@ -42,20 +43,20 @@ var asError = (error) => error instanceof Error ? error : void 0;
 var mapConstraintError = (message, innerError) => {
   const upperMessage = _nullishCoalesce(_optionalChain([message, 'optionalAccess', _ => _.toUpperCase, 'call', _2 => _2()]), () => ( ""));
   if (upperMessage.includes("UNIQUE") || upperMessage.includes("PRIMARY KEY"))
-    return new (0, _chunkXOQHZABKcjs.UniqueConstraintError)(message, innerError);
+    return new (0, _chunkQVEVSWG6cjs.UniqueConstraintError)(message, innerError);
   if (upperMessage.includes("FOREIGN KEY"))
-    return new (0, _chunkXOQHZABKcjs.ForeignKeyViolationError)(message, innerError);
+    return new (0, _chunkQVEVSWG6cjs.ForeignKeyViolationError)(message, innerError);
   if (upperMessage.includes("NOT NULL"))
-    return new (0, _chunkXOQHZABKcjs.NotNullViolationError)(message, innerError);
+    return new (0, _chunkQVEVSWG6cjs.NotNullViolationError)(message, innerError);
   if (upperMessage.includes("CHECK"))
-    return new (0, _chunkXOQHZABKcjs.CheckViolationError)(message, innerError);
-  return new (0, _chunkXOQHZABKcjs.IntegrityConstraintViolationError)(message, innerError);
+    return new (0, _chunkQVEVSWG6cjs.CheckViolationError)(message, innerError);
+  return new (0, _chunkQVEVSWG6cjs.IntegrityConstraintViolationError)(message, innerError);
 };
 var mapSqliteError = (error) => {
-  if (_chunkXOQHZABKcjs.DumboError.isInstanceOf(error)) return error;
+  if (_chunkQVEVSWG6cjs.DumboError.isInstanceOf(error)) return error;
   const code = getSqliteErrorCode(error);
   if (!code)
-    return new (0, _chunkXOQHZABKcjs.DumboError)({
+    return new (0, _chunkQVEVSWG6cjs.DumboError)({
       errorCode: 500,
       message: getErrorMessage(error),
       innerError: asError(error)
@@ -70,78 +71,78 @@ var mapSqliteError = (error) => {
     // ── Busy / lock contention ──
     // SQLITE_BUSY (5): conflict with a separate database connection
     case "SQLITE_BUSY":
-      return new (0, _chunkXOQHZABKcjs.LockNotAvailableError)(message, innerError);
+      return new (0, _chunkQVEVSWG6cjs.LockNotAvailableError)(message, innerError);
     // SQLITE_LOCKED (6): conflict within the same connection or shared cache
     case "SQLITE_LOCKED":
-      return new (0, _chunkXOQHZABKcjs.DeadlockError)(message, innerError);
+      return new (0, _chunkQVEVSWG6cjs.DeadlockError)(message, innerError);
     // SQLITE_PROTOCOL (15): WAL locking race condition
     case "SQLITE_PROTOCOL":
-      return new (0, _chunkXOQHZABKcjs.LockNotAvailableError)(message, innerError);
+      return new (0, _chunkQVEVSWG6cjs.LockNotAvailableError)(message, innerError);
     // ── Connection / open errors ──
     // SQLITE_CANTOPEN (14): unable to open database file
     case "SQLITE_CANTOPEN":
-      return new (0, _chunkXOQHZABKcjs.ConnectionError)(message, innerError);
+      return new (0, _chunkQVEVSWG6cjs.ConnectionError)(message, innerError);
     // SQLITE_NOTADB (26): file is not a database
     case "SQLITE_NOTADB":
-      return new (0, _chunkXOQHZABKcjs.ConnectionError)(message, innerError);
+      return new (0, _chunkQVEVSWG6cjs.ConnectionError)(message, innerError);
     // ── Resource exhaustion ──
     // SQLITE_NOMEM (7): out of memory
     case "SQLITE_NOMEM":
-      return new (0, _chunkXOQHZABKcjs.InsufficientResourcesError)(message, innerError);
+      return new (0, _chunkQVEVSWG6cjs.InsufficientResourcesError)(message, innerError);
     // SQLITE_FULL (13): disk full
     case "SQLITE_FULL":
-      return new (0, _chunkXOQHZABKcjs.InsufficientResourcesError)(message, innerError);
+      return new (0, _chunkQVEVSWG6cjs.InsufficientResourcesError)(message, innerError);
     // ── System / I/O errors ──
     // SQLITE_IOERR (10): operating system I/O error
     case "SQLITE_IOERR":
-      return new (0, _chunkXOQHZABKcjs.SystemError)(message, innerError);
+      return new (0, _chunkQVEVSWG6cjs.SystemError)(message, innerError);
     // SQLITE_CORRUPT (11): database file is corrupted
     case "SQLITE_CORRUPT":
-      return new (0, _chunkXOQHZABKcjs.SystemError)(message, innerError);
+      return new (0, _chunkQVEVSWG6cjs.SystemError)(message, innerError);
     // SQLITE_INTERNAL (2): internal SQLite malfunction
     case "SQLITE_INTERNAL":
-      return new (0, _chunkXOQHZABKcjs.SystemError)(message, innerError);
+      return new (0, _chunkQVEVSWG6cjs.SystemError)(message, innerError);
     // SQLITE_NOLFS (22): large file support unavailable
     case "SQLITE_NOLFS":
-      return new (0, _chunkXOQHZABKcjs.SystemError)(message, innerError);
+      return new (0, _chunkQVEVSWG6cjs.SystemError)(message, innerError);
     // ── Data errors ──
     // SQLITE_TOOBIG (18): string or BLOB too large
     case "SQLITE_TOOBIG":
-      return new (0, _chunkXOQHZABKcjs.DataError)(message, innerError);
+      return new (0, _chunkQVEVSWG6cjs.DataError)(message, innerError);
     // SQLITE_MISMATCH (20): datatype mismatch
     case "SQLITE_MISMATCH":
-      return new (0, _chunkXOQHZABKcjs.DataError)(message, innerError);
+      return new (0, _chunkQVEVSWG6cjs.DataError)(message, innerError);
     // SQLITE_RANGE (25): bind parameter index out of range
     case "SQLITE_RANGE":
-      return new (0, _chunkXOQHZABKcjs.DataError)(message, innerError);
+      return new (0, _chunkQVEVSWG6cjs.DataError)(message, innerError);
     // ── Invalid operations ──
     // SQLITE_ERROR (1): generic SQL error (syntax errors, missing tables, etc.)
     case "SQLITE_ERROR":
-      return new (0, _chunkXOQHZABKcjs.InvalidOperationError)(message, innerError);
+      return new (0, _chunkQVEVSWG6cjs.InvalidOperationError)(message, innerError);
     // SQLITE_READONLY (8): attempt to write to a read-only database
     case "SQLITE_READONLY":
-      return new (0, _chunkXOQHZABKcjs.InvalidOperationError)(message, innerError);
+      return new (0, _chunkQVEVSWG6cjs.InvalidOperationError)(message, innerError);
     // SQLITE_MISUSE (21): API misuse
     case "SQLITE_MISUSE":
-      return new (0, _chunkXOQHZABKcjs.InvalidOperationError)(message, innerError);
+      return new (0, _chunkQVEVSWG6cjs.InvalidOperationError)(message, innerError);
     // SQLITE_AUTH (23): authorization denied
     case "SQLITE_AUTH":
-      return new (0, _chunkXOQHZABKcjs.InvalidOperationError)(message, innerError);
+      return new (0, _chunkQVEVSWG6cjs.InvalidOperationError)(message, innerError);
     // SQLITE_PERM (3): access permission denied
     case "SQLITE_PERM":
-      return new (0, _chunkXOQHZABKcjs.InvalidOperationError)(message, innerError);
+      return new (0, _chunkQVEVSWG6cjs.InvalidOperationError)(message, innerError);
     // SQLITE_SCHEMA (17): schema changed, statement needs re-preparation
     case "SQLITE_SCHEMA":
-      return new (0, _chunkXOQHZABKcjs.InvalidOperationError)(message, innerError);
+      return new (0, _chunkQVEVSWG6cjs.InvalidOperationError)(message, innerError);
     // ── Transaction / abort ──
     // SQLITE_ABORT (4): operation aborted (e.g. by rollback)
     case "SQLITE_ABORT":
-      return new (0, _chunkXOQHZABKcjs.SerializationError)(message, innerError);
+      return new (0, _chunkQVEVSWG6cjs.SerializationError)(message, innerError);
     // SQLITE_INTERRUPT (9): operation interrupted
     case "SQLITE_INTERRUPT":
-      return new (0, _chunkXOQHZABKcjs.SerializationError)(message, innerError);
+      return new (0, _chunkQVEVSWG6cjs.SerializationError)(message, innerError);
   }
-  return new (0, _chunkXOQHZABKcjs.DumboError)({
+  return new (0, _chunkQVEVSWG6cjs.DumboError)({
     errorCode: 500,
     message,
     innerError
@@ -187,16 +188,16 @@ var mapColumnType = (token, { builder }) => {
   }
   builder.addSQL(columnSQL);
 };
-var sqliteColumnProcessors = _chunkXOQHZABKcjs.mapDefaultSQLColumnProcessors.call(void 0, mapColumnType);
+var sqliteColumnProcessors = _chunkQVEVSWG6cjs.mapDefaultSQLColumnProcessors.call(void 0, mapColumnType);
 
 // src/storage/sqlite/core/sql/formatter/index.ts
-var sqliteSQLProcessorsRegistry = _chunkXOQHZABKcjs.SQLProcessorsRegistry.call(void 0, {
-  from: _chunkXOQHZABKcjs.defaultProcessorsRegistry
+var sqliteSQLProcessorsRegistry = _chunkQVEVSWG6cjs.SQLProcessorsRegistry.call(void 0, {
+  from: _chunkQVEVSWG6cjs.defaultProcessorsRegistry
 }).register(sqliteColumnProcessors);
-var sqliteFormatter = _chunkXOQHZABKcjs.SQLFormatter.call(void 0, {
+var sqliteFormatter = _chunkQVEVSWG6cjs.SQLFormatter.call(void 0, {
   processorsRegistry: sqliteSQLProcessorsRegistry
 });
-_chunkXOQHZABKcjs.registerFormatter.call(void 0, "SQLite", sqliteFormatter);
+_chunkQVEVSWG6cjs.registerFormatter.call(void 0, "SQLite", sqliteFormatter);
 
 // src/storage/sqlite/core/execute/execute.ts
 var sqliteExecute = async (database, handle) => {
@@ -209,55 +210,46 @@ var sqliteExecute = async (database, handle) => {
 var sqliteSQLExecutor = (driverType, serializer, formatter, errorMapper) => ({
   driverType,
   query: async (client, sql, options) => {
-    if (_optionalChain([options, 'optionalAccess', _3 => _3.timeoutMs])) {
-      await client.query(_chunkXOQHZABKcjs.SQL`PRAGMA busy_timeout = ${options.timeoutMs}`);
-    }
-    _chunkXOQHZABKcjs.tracer.info("db:sql:query", {
+    _chunkQVEVSWG6cjs.tracer.info("db:sql:query", {
       query: (_nullishCoalesce(formatter, () => ( sqliteFormatter))).format(sql, { serializer }).query,
       params: (_nullishCoalesce(formatter, () => ( sqliteFormatter))).format(sql, { serializer }).params,
       debugSQL: (_nullishCoalesce(formatter, () => ( sqliteFormatter))).describe(sql, { serializer })
     });
     try {
       let result = await client.query(sql, options);
-      if (_optionalChain([options, 'optionalAccess', _4 => _4.mapping])) {
+      if (_optionalChain([options, 'optionalAccess', _3 => _3.mapping])) {
         result = {
           ...result,
           rows: result.rows.map(
-            (row) => _chunkXOQHZABKcjs.mapSQLQueryResult.call(void 0, row, options.mapping)
+            (row) => _chunkQVEVSWG6cjs.mapSQLQueryResult.call(void 0, row, options.mapping)
           )
         };
       }
       return result;
     } catch (error) {
-      _chunkXOQHZABKcjs.tracer.error("db:sql:query:execute:error", { error });
+      _chunkQVEVSWG6cjs.tracer.error("db:sql:query:execute:error", { error });
       throw (_nullishCoalesce(errorMapper, () => ( mapSqliteError)))(error);
     }
   },
   batchQuery: async (client, sqls, options) => {
-    if (_optionalChain([options, 'optionalAccess', _5 => _5.timeoutMs])) {
-      await client.query(_chunkXOQHZABKcjs.SQL`PRAGMA busy_timeout = ${options.timeoutMs}`);
-    }
     try {
       const results = await client.batchQuery(sqls, options);
-      if (_optionalChain([options, 'optionalAccess', _6 => _6.mapping])) {
+      if (_optionalChain([options, 'optionalAccess', _4 => _4.mapping])) {
         return results.map((result) => ({
           ...result,
           rows: result.rows.map(
-            (row) => _chunkXOQHZABKcjs.mapSQLQueryResult.call(void 0, row, options.mapping)
+            (row) => _chunkQVEVSWG6cjs.mapSQLQueryResult.call(void 0, row, options.mapping)
           )
         }));
       }
       return results;
     } catch (error) {
-      _chunkXOQHZABKcjs.tracer.error("db:sql:batch_query:execute:error", { error });
+      _chunkQVEVSWG6cjs.tracer.error("db:sql:batch_query:execute:error", { error });
       throw (_nullishCoalesce(errorMapper, () => ( mapSqliteError)))(error);
     }
   },
   command: async (client, sql, options) => {
-    if (_optionalChain([options, 'optionalAccess', _7 => _7.timeoutMs])) {
-      await client.query(_chunkXOQHZABKcjs.SQL`PRAGMA busy_timeout = ${options.timeoutMs}`);
-    }
-    _chunkXOQHZABKcjs.tracer.info("db:sql:command", {
+    _chunkQVEVSWG6cjs.tracer.info("db:sql:command", {
       query: (_nullishCoalesce(formatter, () => ( sqliteFormatter))).format(sql, { serializer }).query,
       params: (_nullishCoalesce(formatter, () => ( sqliteFormatter))).format(sql, { serializer }).params,
       debugSQL: (_nullishCoalesce(formatter, () => ( sqliteFormatter))).describe(sql, { serializer })
@@ -265,24 +257,52 @@ var sqliteSQLExecutor = (driverType, serializer, formatter, errorMapper) => ({
     try {
       return await client.command(sql, options);
     } catch (error) {
-      _chunkXOQHZABKcjs.tracer.error("db:sql:command:execute:error", { error });
+      _chunkQVEVSWG6cjs.tracer.error("db:sql:command:execute:error", { error });
       throw (_nullishCoalesce(errorMapper, () => ( mapSqliteError)))(error);
     }
   },
   batchCommand: async (client, sqls, options) => {
-    if (_optionalChain([options, 'optionalAccess', _8 => _8.timeoutMs])) {
-      await client.query(_chunkXOQHZABKcjs.SQL`PRAGMA busy_timeout = ${options.timeoutMs}`);
-    }
     try {
       return await client.batchCommand(sqls, options);
     } catch (error) {
-      _chunkXOQHZABKcjs.tracer.error("db:sql:batch_command:execute:error", { error });
+      _chunkQVEVSWG6cjs.tracer.error("db:sql:batch_command:execute:error", { error });
       throw (_nullishCoalesce(errorMapper, () => ( mapSqliteError)))(error);
     }
   },
   formatter: _nullishCoalesce(formatter, () => ( sqliteFormatter))
 });
 
+// src/storage/sqlite/core/pool/dualPool.ts
+var _os = require('os');
+var sqliteDualConnectionPool = (options) => {
+  const { sqliteConnectionFactory, connectionOptions } = options;
+  const readerPoolSize = _nullishCoalesce(options.readerPoolSize, () => ( Math.max(4, _os.cpus.call(void 0, ).length)));
+  const writerPool = _chunkQVEVSWG6cjs.createSingletonConnectionPool.call(void 0, {
+    driverType: options.driverType,
+    getConnection: () => sqliteConnectionFactory(connectionOptions)
+  });
+  const readerPool = _chunkQVEVSWG6cjs.createBoundedConnectionPool.call(void 0, {
+    driverType: options.driverType,
+    getConnection: () => sqliteConnectionFactory(connectionOptions),
+    maxConnections: readerPoolSize
+  });
+  return {
+    driverType: options.driverType,
+    connection: (connectionOptions2) => _optionalChain([connectionOptions2, 'optionalAccess', _5 => _5.readonly]) ? readerPool.connection(connectionOptions2) : writerPool.connection(connectionOptions2),
+    execute: {
+      query: (...args) => readerPool.execute.query(...args),
+      batchQuery: (...args) => readerPool.execute.batchQuery(...args),
+      command: (...args) => writerPool.execute.command(...args),
+      batchCommand: (...args) => writerPool.execute.batchCommand(...args)
+    },
+    withConnection: (handle, connectionOptions2) => _optionalChain([connectionOptions2, 'optionalAccess', _6 => _6.readonly]) ? readerPool.withConnection(handle, connectionOptions2) : writerPool.withConnection(handle, connectionOptions2),
+    transaction: writerPool.transaction,
+    withTransaction: writerPool.withTransaction,
+    close: () => Promise.all([writerPool.close(), readerPool.close()]).then(() => {
+    })
+  };
+};
+
 // src/storage/sqlite/core/pool/pool.ts
 var isInMemoryDatabase = (options) => {
   if ("fileName" in options) {
@@ -295,55 +315,67 @@ var isInMemoryDatabase = (options) => {
 };
 var sqliteAmbientConnectionPool = (options) => {
   const { connection, driverType } = options;
-  return _chunkXOQHZABKcjs.createAmbientConnectionPool.call(void 0, {
+  return _chunkQVEVSWG6cjs.createAmbientConnectionPool.call(void 0, {
     driverType,
     connection
   });
 };
 var sqliteSingletonConnectionPool = (options) => {
   const { driverType, sqliteConnectionFactory, connectionOptions } = options;
-  return _chunkXOQHZABKcjs.createSingletonConnectionPool.call(void 0, {
+  return _chunkQVEVSWG6cjs.createSingletonConnectionPool.call(void 0, {
     driverType,
     getConnection: () => sqliteConnectionFactory(connectionOptions)
   });
 };
 var sqliteAlwaysNewConnectionPool = (options) => {
   const { driverType, sqliteConnectionFactory, connectionOptions } = options;
-  return _chunkXOQHZABKcjs.createAlwaysNewConnectionPool.call(void 0, {
+  return _chunkQVEVSWG6cjs.createAlwaysNewConnectionPool.call(void 0, {
     driverType,
     getConnection: () => sqliteConnectionFactory(connectionOptions)
   });
 };
 var toSqlitePoolOptions = (options) => {
   const { singleton, ...rest } = options;
-  const useSingleton = _nullishCoalesce(singleton, () => ( isInMemoryDatabase(options)));
-  if (useSingleton) {
+  const isInMemory = isInMemoryDatabase(options);
+  if (isInMemory) {
     return { ...rest, singleton: true };
   }
-  return { ...rest, singleton: false };
+  if (singleton === true) {
+    return { ...rest, singleton: true };
+  }
+  return { ...rest, dual: true };
 };
 function sqlitePool(options) {
   const { driverType } = options;
   if (options.connection)
-    return _chunkXOQHZABKcjs.createAmbientConnectionPool.call(void 0, {
+    return _chunkQVEVSWG6cjs.createAmbientConnectionPool.call(void 0, {
       driverType,
       connection: options.connection
     });
+  if ("dual" in options && options.dual) {
+    return sqliteDualConnectionPool(
+      options
+    );
+  }
   if (options.singleton === true && options.sqliteConnectionFactory) {
-    return _chunkXOQHZABKcjs.createSingletonConnectionPool.call(void 0, {
+    return _chunkQVEVSWG6cjs.createSingletonConnectionPool.call(void 0, {
       driverType,
-      getConnection: () => options.sqliteConnectionFactory(options.connectionOptions)
+      getConnection: () => options.sqliteConnectionFactory(
+        options.connectionOptions
+      )
     });
   }
-  return _chunkXOQHZABKcjs.createAlwaysNewConnectionPool.call(void 0, {
+  return _chunkQVEVSWG6cjs.createAlwaysNewConnectionPool.call(void 0, {
     driverType,
-    getConnection: () => options.sqliteConnectionFactory(options.connectionOptions)
+    getConnection: () => options.sqliteConnectionFactory(
+      options.connectionOptions
+    )
   });
 }
 
 // src/storage/sqlite/core/schema/migrations.ts
 var DefaultSQLiteMigratorOptions = {};
-_chunkXOQHZABKcjs.registerDefaultMigratorOptions.call(void 0, "SQLite", DefaultSQLiteMigratorOptions);
+_chunkQVEVSWG6cjs.registerDefaultMigratorOptions.call(void 0, "SQLite", DefaultSQLiteMigratorOptions);
 
 // src/storage/sqlite/core/index.ts
 var SQLiteDatabaseName = "SQLite";
@@ -357,6 +389,41 @@ var SQLiteConnectionString = (connectionString) => {
   }
   return connectionString;
 };
+var parsePragmasFromConnectionString = (connectionString) => {
+  const str = String(connectionString);
+  if (!str.startsWith("file:")) {
+    return {};
+  }
+  const url = new URL(str);
+  const params = url.searchParams;
+  const pragmas = {};
+  const journalMode = params.get("journal_mode");
+  if (journalMode !== null) {
+    pragmas.journal_mode = journalMode;
+  }
+  const synchronous = params.get("synchronous");
+  if (synchronous !== null) {
+    pragmas.synchronous = synchronous;
+  }
+  const cacheSize = params.get("cache_size");
+  if (cacheSize !== null) {
+    pragmas.cache_size = parseInt(cacheSize, 10);
+  }
+  const foreignKeys = params.get("foreign_keys");
+  if (foreignKeys !== null) {
+    const val = foreignKeys.toLowerCase();
+    pragmas.foreign_keys = val === "true" || val === "on" || val === "1";
+  }
+  const tempStore = params.get("temp_store");
+  if (tempStore !== null) {
+    pragmas.temp_store = tempStore.toUpperCase();
+  }
+  const busyTimeout = params.get("busy_timeout");
+  if (busyTimeout !== null) {
+    pragmas.busy_timeout = parseInt(busyTimeout, 10);
+  }
+  return pragmas;
+};
 
 // src/storage/sqlite/core/connections/index.ts
 var isSQLiteError = (error) => {
@@ -391,17 +458,19 @@ var sqliteAmbientClientConnection = (options) => {
     driverType,
     initTransaction,
     allowNestedTransactions,
+    defaultTransactionMode,
     serializer,
     errorMapper
   } = options;
-  return _chunkXOQHZABKcjs.createAmbientConnection.call(void 0, {
+  return _chunkQVEVSWG6cjs.createAmbientConnection.call(void 0, {
     driverType,
     client,
     initTransaction: _nullishCoalesce(initTransaction, () => ( ((connection) => sqliteTransaction(
       driverType,
       connection,
       _nullishCoalesce(allowNestedTransactions, () => ( false)),
-      serializer
+      serializer,
+      defaultTransactionMode
     )))),
     executor: ({ serializer: serializer2 }) => sqliteSQLExecutor(driverType, serializer2, void 0, errorMapper),
     serializer
@@ -417,7 +486,7 @@ var sqliteClientConnection = (options) => {
       await client.connect();
     return client;
   };
-  return _chunkXOQHZABKcjs.createConnection.call(void 0, {
+  return _chunkQVEVSWG6cjs.createConnection.call(void 0, {
     driverType: options.driverType,
     connect,
     close: async () => {
@@ -429,8 +498,9 @@ var sqliteClientConnection = (options) => {
     initTransaction: (connection) => sqliteTransaction(
       options.driverType,
       connection,
-      _nullishCoalesce(_optionalChain([connectionOptions, 'access', _9 => _9.transactionOptions, 'optionalAccess', _10 => _10.allowNestedTransactions]), () => ( false)),
-      serializer
+      _nullishCoalesce(_optionalChain([connectionOptions, 'access', _7 => _7.transactionOptions, 'optionalAccess', _8 => _8.allowNestedTransactions]), () => ( false)),
+      serializer,
+      connectionOptions.defaultTransactionMode
     ),
     executor: ({ serializer: serializer2 }) => sqliteSQLExecutor(options.driverType, serializer2),
     serializer
@@ -445,15 +515,16 @@ var sqlitePoolClientConnection = (options) => {
     await client.connect();
     return client;
   };
-  return _chunkXOQHZABKcjs.createConnection.call(void 0, {
+  return _chunkQVEVSWG6cjs.createConnection.call(void 0, {
     driverType: options.driverType,
     connect,
     close: () => client !== null ? Promise.resolve(client.release()) : Promise.resolve(),
     initTransaction: (connection) => sqliteTransaction(
       options.driverType,
       connection,
-      _nullishCoalesce(_optionalChain([connectionOptions, 'access', _11 => _11.transactionOptions, 'optionalAccess', _12 => _12.allowNestedTransactions]), () => ( false)),
-      serializer
+      _nullishCoalesce(_optionalChain([connectionOptions, 'access', _9 => _9.transactionOptions, 'optionalAccess', _10 => _10.allowNestedTransactions]), () => ( false)),
+      serializer,
+      connectionOptions.defaultTransactionMode
     ),
     executor: ({ serializer: serializer2 }) => sqliteSQLExecutor(options.driverType, serializer2),
     serializer
@@ -463,12 +534,20 @@ function sqliteConnection(options) {
   return options.type === "Client" ? sqliteClientConnection(options) : sqlitePoolClientConnection(options);
 }
 var InMemorySQLiteDatabase = SQLiteConnectionString(":memory:");
+var DEFAULT_SQLITE_PRAGMA_OPTIONS = {
+  journal_mode: "WAL",
+  synchronous: "NORMAL",
+  cache_size: -1e6,
+  foreign_keys: true,
+  temp_store: "MEMORY",
+  busy_timeout: 5e3
+};
 
 // src/storage/sqlite/core/transactions/index.ts
-var sqliteTransaction = (driverType, connection, allowNestedTransactions, serializer) => (getClient, options) => {
+var sqliteTransaction = (driverType, connection, allowNestedTransactions, serializer, defaultTransactionMode) => (getClient, options) => {
   const transactionCounter = transactionNestingCounter();
-  allowNestedTransactions = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _13 => _13.allowNestedTransactions]), () => ( allowNestedTransactions));
-  return {
+  allowNestedTransactions = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _11 => _11.allowNestedTransactions]), () => ( allowNestedTransactions));
+  const transaction = {
     connection: connection(),
     driverType,
     begin: async function() {
@@ -476,32 +555,37 @@ var sqliteTransaction = (driverType, connection, allowNestedTransactions, serial
       if (allowNestedTransactions) {
         if (transactionCounter.level >= 1) {
           transactionCounter.increment();
-          await client.query(
-            _chunkXOQHZABKcjs.SQL`SAVEPOINT transaction${_chunkXOQHZABKcjs.SQL.plain(transactionCounter.level.toString())}`
-          );
+          if (_optionalChain([options, 'optionalAccess', _12 => _12.useSavepoints])) {
+            await client.query(
+              _chunkQVEVSWG6cjs.SQL`SAVEPOINT transaction${_chunkQVEVSWG6cjs.SQL.plain(transactionCounter.level.toString())}`
+            );
+          }
           return;
         }
         transactionCounter.increment();
       }
-      await client.query(_chunkXOQHZABKcjs.SQL`BEGIN TRANSACTION`);
+      const mode = _nullishCoalesce(_nullishCoalesce(_optionalChain([options, 'optionalAccess', _13 => _13.mode]), () => ( defaultTransactionMode)), () => ( "IMMEDIATE"));
+      await client.query(_chunkQVEVSWG6cjs.SQL`BEGIN ${_chunkQVEVSWG6cjs.SQL.plain(mode)} TRANSACTION`);
     },
     commit: async function() {
       const client = await getClient;
       try {
         if (allowNestedTransactions) {
           if (transactionCounter.level > 1) {
-            await client.query(
-              _chunkXOQHZABKcjs.SQL`RELEASE transaction${_chunkXOQHZABKcjs.SQL.plain(transactionCounter.level.toString())}`
-            );
+            if (_optionalChain([options, 'optionalAccess', _14 => _14.useSavepoints])) {
+              await client.query(
+                _chunkQVEVSWG6cjs.SQL`RELEASE transaction${_chunkQVEVSWG6cjs.SQL.plain(transactionCounter.level.toString())}`
+              );
+            }
             transactionCounter.decrement();
             return;
           }
           transactionCounter.reset();
         }
-        await client.query(_chunkXOQHZABKcjs.SQL`COMMIT`);
+        await client.query(_chunkQVEVSWG6cjs.SQL`COMMIT`);
       } finally {
-        if (_optionalChain([options, 'optionalAccess', _14 => _14.close]))
-          await _optionalChain([options, 'optionalAccess', _15 => _15.close, 'call', _16 => _16(
+        if (_optionalChain([options, 'optionalAccess', _15 => _15.close]))
+          await _optionalChain([options, 'optionalAccess', _16 => _16.close, 'call', _17 => _17(
             client
           )]);
       }
@@ -515,19 +599,21 @@ var sqliteTransaction = (driverType, connection, allowNestedTransactions, serial
             return;
           }
         }
-        await client.query(_chunkXOQHZABKcjs.SQL`ROLLBACK`);
+        await client.query(_chunkQVEVSWG6cjs.SQL`ROLLBACK`);
       } finally {
-        if (_optionalChain([options, 'optionalAccess', _17 => _17.close]))
-          await _optionalChain([options, 'optionalAccess', _18 => _18.close, 'call', _19 => _19(
+        if (_optionalChain([options, 'optionalAccess', _18 => _18.close]))
+          await _optionalChain([options, 'optionalAccess', _19 => _19.close, 'call', _20 => _20(
             client,
             error
           )]);
       }
     },
-    execute: _chunkXOQHZABKcjs.sqlExecutor.call(void 0, sqliteSQLExecutor(driverType, serializer), {
+    execute: _chunkQVEVSWG6cjs.sqlExecutor.call(void 0, sqliteSQLExecutor(driverType, serializer), {
       connect: () => getClient
-    })
+    }),
+    _transactionOptions: _nullishCoalesce(options, () => ( {}))
   };
+  return transaction;
 };
 
 
@@ -552,5 +638,7 @@ var sqliteTransaction = (driverType, connection, allowNestedTransactions, serial
 
 
 
-exports.mapSqliteError = mapSqliteError; exports.sqliteFormatter = sqliteFormatter; exports.sqliteExecute = sqliteExecute; exports.sqliteSQLExecutor = sqliteSQLExecutor; exports.sqliteTransaction = sqliteTransaction; exports.SQLiteConnectionString = SQLiteConnectionString; exports.isSQLiteError = isSQLiteError; exports.transactionNestingCounter = transactionNestingCounter; exports.sqliteAmbientClientConnection = sqliteAmbientClientConnection; exports.sqliteClientConnection = sqliteClientConnection; exports.sqlitePoolClientConnection = sqlitePoolClientConnection; exports.sqliteConnection = sqliteConnection; exports.InMemorySQLiteDatabase = InMemorySQLiteDatabase; exports.isInMemoryDatabase = isInMemoryDatabase; exports.sqliteAmbientConnectionPool = sqliteAmbientConnectionPool; exports.sqliteSingletonConnectionPool = sqliteSingletonConnectionPool; exports.sqliteAlwaysNewConnectionPool = sqliteAlwaysNewConnectionPool; exports.toSqlitePoolOptions = toSqlitePoolOptions; exports.sqlitePool = sqlitePool; exports.DefaultSQLiteMigratorOptions = DefaultSQLiteMigratorOptions; exports.SQLiteDatabaseName = SQLiteDatabaseName;
-//# sourceMappingURL=chunk-AMACBMAZ.cjs.map
+
+
+exports.mapSqliteError = mapSqliteError; exports.sqliteFormatter = sqliteFormatter; exports.sqliteExecute = sqliteExecute; exports.sqliteSQLExecutor = sqliteSQLExecutor; exports.sqliteTransaction = sqliteTransaction; exports.SQLiteConnectionString = SQLiteConnectionString; exports.parsePragmasFromConnectionString = parsePragmasFromConnectionString; exports.isSQLiteError = isSQLiteError; exports.transactionNestingCounter = transactionNestingCounter; exports.sqliteAmbientClientConnection = sqliteAmbientClientConnection; exports.sqliteClientConnection = sqliteClientConnection; exports.sqlitePoolClientConnection = sqlitePoolClientConnection; exports.sqliteConnection = sqliteConnection; exports.InMemorySQLiteDatabase = InMemorySQLiteDatabase; exports.DEFAULT_SQLITE_PRAGMA_OPTIONS = DEFAULT_SQLITE_PRAGMA_OPTIONS; exports.isInMemoryDatabase = isInMemoryDatabase; exports.sqliteAmbientConnectionPool = sqliteAmbientConnectionPool; exports.sqliteSingletonConnectionPool = sqliteSingletonConnectionPool; exports.sqliteAlwaysNewConnectionPool = sqliteAlwaysNewConnectionPool; exports.toSqlitePoolOptions = toSqlitePoolOptions; exports.sqlitePool = sqlitePool; exports.DefaultSQLiteMigratorOptions = DefaultSQLiteMigratorOptions; exports.SQLiteDatabaseName = SQLiteDatabaseName;
+//# sourceMappingURL=chunk-7D7WADBK.cjs.map