@event-driven-io/dumbo 0.13.0-beta.4 → 0.13.0-beta.41

package/dist/sqlite3.cjs

@@ -1,282 +1,446 @@
-"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-var _chunkIYEHOE4Scjs = require('./chunk-IYEHOE4S.cjs');
-require('./chunk-32AL3EAS.cjs');
-
-
-
-
-var _chunkOJ34O3Q2cjs = require('./chunk-OJ34O3Q2.cjs');
-
-// src/storage/sqlite/sqlite3/connections/connection.ts
-var _sqlite3 = require('sqlite3'); var _sqlite32 = _interopRequireDefault(_sqlite3);
-var SQLite3DriverType = "SQLite:sqlite3";
-var sqlite3Client = (options) => {
-  let db;
-  let isClosed = false;
-  const connect = () => db ? Promise.resolve() : new Promise((resolve, reject) => {
-    try {
-      db = new _sqlite32.default.Database(
-        _nullishCoalesce(_nullishCoalesce(options.fileName, () => ( options.connectionString)), () => ( _chunkIYEHOE4Scjs.InMemorySQLiteDatabase)),
-        _sqlite32.default.OPEN_URI | _sqlite32.default.OPEN_READWRITE | _sqlite32.default.OPEN_CREATE,
-        (err) => {
-          if (err) {
-            reject(err);
-            return;
-          }
-        }
-      );
-      db.run("PRAGMA journal_mode = WAL;", (err) => {
-        if (err) {
-          reject(err);
-          return;
-        }
-        resolve();
-      });
-    } catch (error) {
-      reject(error);
-    }
-  });
-  const executeQuery = (sql, params) => new Promise((resolve, reject) => {
-    try {
-      db.all(sql, _nullishCoalesce(params, () => ( [])), (err, result) => {
-        if (err) {
-          reject(err);
-          return;
-        }
-        resolve(result);
-      });
-    } catch (error) {
-      reject(error);
-    }
-  });
-  const executeCommand = (sql, params, options2) => new Promise((resolve, reject) => {
-    try {
-      if (_optionalChain([options2, 'optionalAccess', _ => _.ignoreChangesCount]) === true) {
-        db.run(
-          sql,
-          _nullishCoalesce(params, () => ( [])),
-          function(err, rows) {
-            if (err) {
-              reject(err);
-              return;
-            }
-            resolve({
-              rowCount: 0,
-              rows: _nullishCoalesce(rows, () => ( []))
-            });
-          }
-        );
-      }
-      db.serialize(() => {
-        db.all(sql, _nullishCoalesce(params, () => ( [])), (err, rows) => {
-          if (err) {
-            reject(err);
-            return;
-          }
-          db.get(
-            "SELECT changes() as changes",
-            (changesErr, row) => {
-              if (changesErr) {
-                reject(changesErr);
-                return;
-              }
-              resolve({
-                rowCount: _nullishCoalesce(_optionalChain([row, 'optionalAccess', _2 => _2.changes]), () => ( 0)),
-                rows: _nullishCoalesce(rows, () => ( []))
-              });
-            }
-          );
-        });
-      });
-    } catch (error) {
-      reject(error);
-    }
-  });
-  return {
-    connect,
-    close: () => {
-      if (isClosed) {
-        return Promise.resolve();
-      }
-      isClosed = true;
-      if (db)
-        return new Promise((resolve, reject) => {
-          db.close((err) => {
-            if (err) {
-              reject(err);
-              return;
-            }
-            resolve();
-          });
-        });
-      return Promise.resolve();
-    },
-    query: async (sql, _options) => {
-      const { query, params } = _chunkIYEHOE4Scjs.sqliteFormatter.format(sql);
-      const result = await executeQuery(
-        query,
-        params
-      );
-      return { rowCount: result.length, rows: result };
-    },
-    batchQuery: async (sqls, _options) => {
-      const results = [];
-      for (const sql of sqls) {
-        const { query, params } = _chunkIYEHOE4Scjs.sqliteFormatter.format(sql);
-        const result = await executeQuery(
-          query,
-          params
-        );
-        results.push({ rowCount: result.length, rows: result });
-      }
-      return results;
-    },
-    command: async (sql, options2) => {
-      const { query, params } = _chunkIYEHOE4Scjs.sqliteFormatter.format(sql);
-      return executeCommand(
-        query,
-        params,
-        options2
-      );
-    },
-    batchCommand: async (sqls, options2) => {
-      const results = [];
-      for (const sql of sqls) {
-        const { query, params } = _chunkIYEHOE4Scjs.sqliteFormatter.format(sql);
-        const result = await executeCommand(
-          query,
-          params,
-          options2
-        );
-        results.push(result);
-      }
-      return results;
-    }
-  };
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+const require_core = require('./core-D5W_5J8k.cjs');
+const require_sqliteMetadata = require('./sqliteMetadata-CpmoZxqb.cjs');
+const require_core$1 = require('./core-CIVu4cNp.cjs');
+let sqlite3 = require("sqlite3");
+sqlite3 = require_core.__toESM(sqlite3, 1);
+let os = require("os");
+let node_async_hooks = require("node:async_hooks");
+
+//#region src/storage/sqlite/core/connections/pragmas.ts
+const mergePragmaOptions = (connectionString, userOptions) => {
+	const connectionStringPragmas = require_core$1.parsePragmasFromConnectionString(connectionString);
+	return {
+		...require_core$1.DEFAULT_SQLITE_PRAGMA_OPTIONS,
+		...connectionStringPragmas,
+		...userOptions
+	};
 };
-var checkConnection = async (fileName) => {
-  const client = sqlite3Client({
-    fileName
-  });
-  try {
-    await client.query(_chunkOJ34O3Q2cjs.SQL`SELECT 1`);
-    return { successful: true };
-  } catch (error) {
-    const code = error instanceof Error && "code" in error && typeof error.code === "string" ? error.code : void 0;
-    return {
-      successful: false,
-      errorType: code === "SQLITE_CANTOPEN" ? "ConnectionRefused" : code === "SQLITE_AUTH" ? "Authentication" : "Unknown",
-      code,
-      error
-    };
-  } finally {
-    await client.close();
-  }
+const buildConnectionPragmaStatements = (pragmas) => [
+	{
+		pragma: "busy_timeout",
+		value: pragmas.busy_timeout
+	},
+	{
+		pragma: "synchronous",
+		value: pragmas.synchronous
+	},
+	{
+		pragma: "cache_size",
+		value: pragmas.cache_size
+	},
+	{
+		pragma: "foreign_keys",
+		value: pragmas.foreign_keys ? "ON" : "OFF"
+	},
+	{
+		pragma: "temp_store",
+		value: pragmas.temp_store
+	},
+	...pragmas.mmap_size !== void 0 ? [{
+		pragma: "mmap_size",
+		value: pragmas.mmap_size
+	}] : []
+];
+const buildDatabasePragmaStatements = (pragmas) => [{
+	pragma: "journal_mode",
+	value: pragmas.journal_mode
+}];
+
+//#endregion
+//#region src/storage/sqlite/sqlite3/connections/connection.ts
+const SQLite3DriverType = "SQLite:sqlite3";
+const hasReturningClause = (sql) => /\bRETURNING\b/i.test(sql);
+const applyPragma = (database, pragma, value) => {
+	return new Promise((resolve, reject) => {
+		database.run(`PRAGMA ${pragma} = ${value};`, (err) => {
+			if (err) reject(err);
+			else resolve();
+		});
+	});
 };
-var sqlite3Connection = (options) => _chunkIYEHOE4Scjs.sqliteConnection.call(void 0, {
-  type: "Client",
-  driverType: SQLite3DriverType,
-  sqliteClientFactory: (connectionOptions) => {
-    if ("client" in connectionOptions && connectionOptions.client) {
-      return connectionOptions.client;
-    }
-    return sqlite3Client(connectionOptions);
-  },
-  connectionOptions: options
+const queryPragma = (database, pragma) => new Promise((resolve, reject) => {
+	database.get(`PRAGMA ${pragma};`, (err, row) => {
+		if (err) reject(err);
+		else resolve(row?.[pragma] ?? "");
+	});
 });
-
-// src/storage/sqlite/sqlite3/index.ts
-var sqlite3Pool = (options) => _chunkIYEHOE4Scjs.sqlitePool.call(void 0, 
-  _chunkIYEHOE4Scjs.toSqlitePoolOptions.call(void 0, {
-    ...options,
-    driverType: SQLite3DriverType,
-    ..."connection" in options ? {} : {
-      connectionOptions: options,
-      sqliteConnectionFactory: (opts) => sqlite3Connection(opts)
-    }
-  })
-);
-var tryParseConnectionString = (connectionString) => {
-  try {
-    return _chunkIYEHOE4Scjs.SQLiteConnectionString.call(void 0, connectionString);
-  } catch (e) {
-    return null;
-  }
-};
-var sqlite3DatabaseDriver = {
-  driverType: SQLite3DriverType,
-  createPool: (options) => sqlite3Pool(options),
-  sqlFormatter: _chunkIYEHOE4Scjs.sqliteFormatter,
-  defaultMigratorOptions: _chunkIYEHOE4Scjs.DefaultSQLiteMigratorOptions,
-  getDatabaseNameOrDefault: () => _chunkIYEHOE4Scjs.InMemorySQLiteDatabase,
-  canHandle: _chunkOJ34O3Q2cjs.canHandleDriverWithConnectionString.call(void 0, 
-    SQLite3DriverType,
-    tryParseConnectionString
-  )
+const applyPragmas = (database, pragmas) => pragmas.reduce((promise, { pragma, value }) => promise.then(() => applyPragma(database, pragma, value)), Promise.resolve());
+const sqlite3Client = (options) => {
+	let db;
+	let isClosed = false;
+	const { serializer } = options;
+	const connectionString = options.fileName ?? options.connectionString ?? require_core$1.InMemorySQLiteDatabase;
+	const finalPragmas = mergePragmaOptions(String(connectionString), options.pragmaOptions);
+	const connectionPragmas = buildConnectionPragmaStatements(finalPragmas);
+	const connect = () => db ? Promise.resolve() : new Promise((resolve, reject) => {
+		try {
+			db = new sqlite3.default.Database(connectionString, sqlite3.default.OPEN_URI | sqlite3.default.OPEN_READWRITE | sqlite3.default.OPEN_CREATE, (err) => {
+				if (err) {
+					reject(err);
+					return;
+				}
+				const busyTimeout = finalPragmas.busy_timeout ?? require_core$1.DEFAULT_SQLITE_PRAGMA_OPTIONS.busy_timeout;
+				db.configure("busyTimeout", busyTimeout);
+				applyPragmas(db, connectionPragmas.filter((p) => p.pragma !== "busy_timeout")).then(async () => {
+					if (options.skipDatabasePragmas) return;
+					const databasePragmas = buildDatabasePragmaStatements(finalPragmas);
+					for (const { pragma, value } of databasePragmas) if ((await queryPragma(db, pragma)).toUpperCase() !== String(value).toUpperCase()) await applyPragma(db, pragma, value);
+				}).then(() => resolve()).catch(reject);
+			});
+		} catch (error) {
+			reject(error instanceof Error ? error : new Error(String(error)));
+		}
+	});
+	const executeQuery = (sql, params) => new Promise((resolve, reject) => {
+		try {
+			db.all(sql, params ?? [], (err, result) => {
+				if (err) {
+					reject(err);
+					return;
+				}
+				resolve(result);
+			});
+		} catch (error) {
+			reject(error instanceof Error ? error : new Error(String(error)));
+		}
+	});
+	const executeCommand = (sql, params, options) => new Promise((resolve, reject) => {
+		try {
+			if (options?.ignoreChangesCount === true) {
+				db.run(sql, params ?? [], function(err, rows) {
+					if (err) {
+						reject(err);
+						return;
+					}
+					resolve({
+						rowCount: 0,
+						rows: rows ?? []
+					});
+				});
+				return;
+			}
+			if (hasReturningClause(sql)) {
+				db.all(sql, params ?? [], (err, rows) => {
+					if (err) return reject(err);
+					resolve({
+						rowCount: rows.length,
+						rows
+					});
+				});
+				return;
+			}
+			db.serialize(() => {
+				let hasFailed = false;
+				let resultRows = [];
+				db.all(sql, params ?? [], (err, rows) => {
+					if (err) {
+						hasFailed = true;
+						return reject(err);
+					}
+					resultRows = rows;
+				});
+				db.get("SELECT changes() as changes", (err, row) => {
+					if (hasFailed) return;
+					if (err) return reject(err);
+					resolve({
+						rowCount: row?.changes ?? 0,
+						rows: resultRows
+					});
+				});
+			});
+		} catch (error) {
+			reject(error instanceof Error ? error : new Error(String(error)));
+		}
+	});
+	return {
+		connect,
+		close: async () => {
+			if (isClosed) return;
+			isClosed = true;
+			if (db) try {
+				await new Promise((resolve, reject) => {
+					db.close((err) => {
+						if (err) {
+							reject(err);
+							return;
+						}
+						resolve();
+					});
+				});
+			} catch (error) {
+				throw require_core$1.mapSqliteError(error);
+			}
+		},
+		query: async (sql, _options) => {
+			try {
+				const { query, params } = require_core$1.sqliteFormatter.format(sql, { serializer });
+				const result = await executeQuery(query, params);
+				return {
+					rowCount: result.length,
+					rows: result
+				};
+			} catch (error) {
+				throw require_core$1.mapSqliteError(error);
+			}
+		},
+		batchQuery: async (sqls, _options) => {
+			try {
+				const results = [];
+				for (const sql of sqls) {
+					const { query, params } = require_core$1.sqliteFormatter.format(sql, { serializer });
+					const result = await executeQuery(query, params);
+					results.push({
+						rowCount: result.length,
+						rows: result
+					});
+				}
+				return results;
+			} catch (error) {
+				throw require_core$1.mapSqliteError(error);
+			}
+		},
+		command: async (sql, options) => {
+			try {
+				const { query, params } = require_core$1.sqliteFormatter.format(sql, { serializer });
+				return await executeCommand(query, params, options);
+			} catch (error) {
+				throw require_core$1.mapSqliteError(error);
+			}
+		},
+		batchCommand: async (sqls, options) => {
+			try {
+				const results = [];
+				for (let i = 0; i < sqls.length; i++) {
+					const { query, params } = require_core$1.sqliteFormatter.format(sqls[i], { serializer });
+					const result = await executeCommand(query, params, options);
+					results.push(result);
+					if (options?.assertChanges && (result.rowCount ?? 0) === 0) throw new require_core.BatchCommandNoChangesError(i);
+				}
+				return results;
+			} catch (error) {
+				throw require_core$1.mapSqliteError(error);
+			}
+		}
+	};
 };
-var useSqlite3DatabaseDriver = () => {
-  _chunkOJ34O3Q2cjs.dumboDatabaseDriverRegistry.register(
-    SQLite3DriverType,
-    sqlite3DatabaseDriver
-  );
+const checkConnection = async (fileName, serializer) => {
+	const client = sqlite3Client({
+		fileName,
+		serializer
+	});
+	try {
+		await client.query(require_core.SQL`SELECT 1`);
+		return { successful: true };
+	} catch (error) {
+		const code = error instanceof Error && "code" in error && typeof error.code === "string" ? error.code : void 0;
+		return {
+			successful: false,
+			errorType: code === "SQLITE_CANTOPEN" ? "ConnectionRefused" : code === "SQLITE_AUTH" ? "Authentication" : "Unknown",
+			code,
+			error
+		};
+	} finally {
+		await client.close();
+	}
 };
-useSqlite3DatabaseDriver();
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
+const sqlite3Connection = (options) => require_core$1.sqliteConnection({
+	type: "Client",
+	driverType: SQLite3DriverType,
+	sqliteClientFactory: (connectionOptions) => {
+		if ("client" in connectionOptions && connectionOptions.client) return connectionOptions.client;
+		return sqlite3Client({
+			...connectionOptions,
+			serializer: options.serializer
+		});
+	},
+	connectionOptions: options,
+	serializer: options.serializer
+});
 
+//#endregion
+//#region src/storage/sqlite/sqlite3/pool/singletonPool.ts
+const sqlite3SingletonPool = (options) => {
+	const inner = require_core.createSingletonConnectionPool({
+		driverType: options.driverType,
+		getConnection: options.getConnection,
+		...options.closeConnection ? { closeConnection: options.closeConnection } : {}
+	});
+	const taskProcessor = new require_core.TaskProcessor({
+		maxActiveTasks: 1,
+		maxQueueSize: options.maxQueueSize ?? 1e3
+	});
+	const insideWriterTask = new node_async_hooks.AsyncLocalStorage();
+	const enqueue = (op) => {
+		if (insideWriterTask.getStore() === true) return op();
+		return taskProcessor.enqueue(({ ack }) => insideWriterTask.run(true, async () => {
+			try {
+				return await op();
+			} finally {
+				ack();
+			}
+		}));
+	};
+	return {
+		driverType: inner.driverType,
+		connection: inner.connection.bind(inner),
+		transaction: inner.transaction.bind(inner),
+		withConnection: (handle, connectionOptions) => enqueue(() => inner.withConnection(handle, connectionOptions)),
+		withTransaction: (handle, transactionOptions) => enqueue(() => inner.withTransaction(handle, transactionOptions)),
+		execute: {
+			query: (sql, queryOptions) => enqueue(() => inner.execute.query(sql, queryOptions)),
+			batchQuery: (sqls, queryOptions) => enqueue(() => inner.execute.batchQuery(sqls, queryOptions)),
+			command: (sql, commandOptions) => enqueue(() => inner.execute.command(sql, commandOptions)),
+			batchCommand: (sqls, commandOptions) => enqueue(() => inner.execute.batchCommand(sqls, commandOptions))
+		},
+		close: async () => {
+			await taskProcessor.stop();
+			await inner.close();
+		}
+	};
+};
 
+//#endregion
+//#region src/storage/sqlite/sqlite3/pool/dualPool.ts
+const sqliteDualConnectionPool = (options) => {
+	const { sqliteConnectionFactory, connectionOptions } = options;
+	const readerPoolSize = options.readerPoolSize ?? Math.max(4, (0, os.cpus)().length);
+	let databaseInitPromise = null;
+	const guardSingleConnection = require_core.guardInitializedOnce(async () => {
+		if (databaseInitPromise !== null) return databaseInitPromise;
+		const initConnection = sqliteConnectionFactory({
+			...connectionOptions,
+			skipDatabasePragmas: false,
+			readonly: false
+		});
+		const initPromise = initConnection.open();
+		databaseInitPromise = initPromise;
+		try {
+			await initPromise;
+			await initConnection.close();
+		} catch (error) {
+			databaseInitPromise = null;
+			await initConnection.close();
+			throw require_core$1.mapSqliteError(error);
+		}
+	});
+	const ensureDatabaseInitialized = async () => {
+		if (databaseInitPromise !== null) return databaseInitPromise;
+		return guardSingleConnection.ensureInitialized();
+	};
+	const wrappedConnectionFactory = async (readonly, connectionOptions) => {
+		await ensureDatabaseInitialized();
+		const connection = sqliteConnectionFactory({
+			...connectionOptions,
+			skipDatabasePragmas: true,
+			readonly
+		});
+		await connection.open();
+		return connection;
+	};
+	const writerPool = sqlite3SingletonPool({
+		driverType: options.driverType,
+		getConnection: () => wrappedConnectionFactory(false, connectionOptions)
+	});
+	const readerPool = require_core.createBoundedConnectionPool({
+		driverType: options.driverType,
+		getConnection: () => wrappedConnectionFactory(true, connectionOptions),
+		maxConnections: readerPoolSize
+	});
+	return {
+		driverType: options.driverType,
+		connection: (connectionOptions) => connectionOptions?.readonly ? readerPool.connection(connectionOptions) : writerPool.connection(connectionOptions),
+		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, connectionOptions) => connectionOptions?.readonly ? readerPool.withConnection(handle, connectionOptions) : writerPool.withConnection(handle, connectionOptions),
+		transaction: writerPool.transaction,
+		withTransaction: writerPool.withTransaction,
+		close: async () => {
+			await guardSingleConnection.stop();
+			await Promise.all([writerPool.close(), readerPool.close()]);
+		}
+	};
+};
 
-exports.DefaultSQLiteMigratorOptions = _chunkIYEHOE4Scjs.DefaultSQLiteMigratorOptions; exports.InMemorySQLiteDatabase = _chunkIYEHOE4Scjs.InMemorySQLiteDatabase; exports.SQLite3DriverType = SQLite3DriverType; exports.SQLiteConnectionString = _chunkIYEHOE4Scjs.SQLiteConnectionString; exports.SQLiteDatabaseName = _chunkIYEHOE4Scjs.SQLiteDatabaseName; exports.checkConnection = checkConnection; exports.connectionPool = sqlite3Pool; exports.databaseDriver = sqlite3DatabaseDriver; exports.defaultPostgreSqlDatabase = _chunkIYEHOE4Scjs.defaultPostgreSqlDatabase; exports.isInMemoryDatabase = _chunkIYEHOE4Scjs.isInMemoryDatabase; exports.isSQLiteError = _chunkIYEHOE4Scjs.isSQLiteError; exports.sqlite3Client = sqlite3Client; exports.sqlite3Connection = sqlite3Connection; exports.sqlite3DatabaseDriver = sqlite3DatabaseDriver; exports.sqlite3Pool = sqlite3Pool; exports.sqliteAlwaysNewConnectionPool = _chunkIYEHOE4Scjs.sqliteAlwaysNewConnectionPool; exports.sqliteAmbientClientConnection = _chunkIYEHOE4Scjs.sqliteAmbientClientConnection; exports.sqliteAmbientConnectionPool = _chunkIYEHOE4Scjs.sqliteAmbientConnectionPool; exports.sqliteClient = sqlite3Client; exports.sqliteClientConnection = _chunkIYEHOE4Scjs.sqliteClientConnection; exports.sqliteConnection = _chunkIYEHOE4Scjs.sqliteConnection; exports.sqliteExecute = _chunkIYEHOE4Scjs.sqliteExecute; exports.sqliteFormatter = _chunkIYEHOE4Scjs.sqliteFormatter; exports.sqlitePool = _chunkIYEHOE4Scjs.sqlitePool; exports.sqlitePoolClientConnection = _chunkIYEHOE4Scjs.sqlitePoolClientConnection; exports.sqliteSQLExecutor = _chunkIYEHOE4Scjs.sqliteSQLExecutor; exports.sqliteSingletonConnectionPool = _chunkIYEHOE4Scjs.sqliteSingletonConnectionPool; exports.sqliteTransaction = _chunkIYEHOE4Scjs.sqliteTransaction; exports.tableExists = _chunkIYEHOE4Scjs.tableExists; exports.tableExistsSQL = _chunkIYEHOE4Scjs.tableExistsSQL; exports.toSqlitePoolOptions = _chunkIYEHOE4Scjs.toSqlitePoolOptions; exports.transactionNestingCounter = _chunkIYEHOE4Scjs.transactionNestingCounter; exports.useSqlite3DatabaseDriver = useSqlite3DatabaseDriver;
+//#endregion
+//#region src/storage/sqlite/sqlite3/index.ts
+const sqlite3Pool = (options) => {
+	if ("connection" in options && options.connection) return require_core$1.sqlitePool(require_core$1.toSqlitePoolOptions({
+		...options,
+		driverType: SQLite3DriverType
+	}));
+	const sqliteConnectionFactory = (opts) => sqlite3Connection({
+		...opts,
+		serializer: options.serializer ?? require_core.JSONSerializer
+	});
+	if (require_core$1.isInMemoryDatabase(options) || "client" in options && Boolean(options.client) || options.singleton === true) return sqlite3SingletonPool({
+		driverType: SQLite3DriverType,
+		getConnection: () => sqliteConnectionFactory(options)
+	});
+	const readerPoolSize = options.readerPoolSize;
+	return sqliteDualConnectionPool({
+		driverType: SQLite3DriverType,
+		sqliteConnectionFactory,
+		connectionOptions: options,
+		...readerPoolSize !== void 0 ? { readerPoolSize } : {}
+	});
+};
+const tryParseConnectionString = (connectionString) => {
+	try {
+		return require_core$1.SQLiteConnectionString(connectionString);
+	} catch {
+		return null;
+	}
+};
+const sqlite3DumboDriver = {
+	driverType: SQLite3DriverType,
+	createPool: (options) => sqlite3Pool(options),
+	sqlFormatter: require_core$1.sqliteFormatter,
+	defaultMigratorOptions: require_core$1.DefaultSQLiteMigratorOptions,
+	canHandle: require_core.canHandleDriverWithConnectionString(SQLite3DriverType, tryParseConnectionString),
+	databaseMetadata: require_sqliteMetadata.sqliteMetadata
+};
+const useSqlite3DumboDriver = () => {
+	require_core.dumboDatabaseDriverRegistry.register(SQLite3DriverType, sqlite3DumboDriver);
+};
+useSqlite3DumboDriver();
+
+//#endregion
+exports.DEFAULT_SQLITE_PRAGMA_OPTIONS = require_core$1.DEFAULT_SQLITE_PRAGMA_OPTIONS;
+exports.DefaultSQLiteMigratorOptions = require_core$1.DefaultSQLiteMigratorOptions;
+exports.InMemorySQLiteDatabase = require_core$1.InMemorySQLiteDatabase;
+exports.SQLite3DriverType = SQLite3DriverType;
+exports.SQLiteConnectionString = require_core$1.SQLiteConnectionString;
+exports.SQLiteDatabaseName = require_core$1.SQLiteDatabaseName;
+exports.checkConnection = checkConnection;
+exports.defaultSQLiteDatabase = require_sqliteMetadata.defaultSQLiteDatabase;
+exports.isInMemoryDatabase = require_core$1.isInMemoryDatabase;
+exports.isSQLiteError = require_core$1.isSQLiteError;
+exports.mapSqliteError = require_core$1.mapSqliteError;
+exports.parsePragmasFromConnectionString = require_core$1.parsePragmasFromConnectionString;
+exports.sqlite3Client = sqlite3Client;
+exports.sqlite3Connection = sqlite3Connection;
+exports.sqlite3DumboDriver = sqlite3DumboDriver;
+exports.sqlite3Pool = sqlite3Pool;
+exports.sqliteAlwaysNewConnectionPool = require_core$1.sqliteAlwaysNewConnectionPool;
+exports.sqliteAmbientClientConnection = require_core$1.sqliteAmbientClientConnection;
+exports.sqliteAmbientConnectionPool = require_core$1.sqliteAmbientConnectionPool;
+exports.sqliteClientConnection = require_core$1.sqliteClientConnection;
+exports.sqliteConnection = require_core$1.sqliteConnection;
+exports.sqliteExecute = require_core$1.sqliteExecute;
+exports.sqliteFormatter = require_core$1.sqliteFormatter;
+exports.sqliteMetadata = require_sqliteMetadata.sqliteMetadata;
+exports.sqlitePool = require_core$1.sqlitePool;
+exports.sqlitePoolClientConnection = require_core$1.sqlitePoolClientConnection;
+exports.sqliteSQLExecutor = require_core$1.sqliteSQLExecutor;
+exports.sqliteSingletonConnectionPool = require_core$1.sqliteSingletonConnectionPool;
+exports.sqliteTransaction = require_core$1.sqliteTransaction;
+exports.tableExists = require_sqliteMetadata.tableExists;
+exports.toSqlitePoolOptions = require_core$1.toSqlitePoolOptions;
+exports.transactionNestingCounter = require_core$1.transactionNestingCounter;
+exports.useSqlite3DumboDriver = useSqlite3DumboDriver;
 //# sourceMappingURL=sqlite3.cjs.map