@event-driven-io/dumbo 0.13.0-beta.35 → 0.13.0-beta.37

package/dist/sqlite3.cjs

@@ -1,394 +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 _chunkJIZGCEPEcjs = require('./chunk-JIZGCEPE.cjs');
-
-
-
-
-var _chunkRQ3KKMTPcjs = require('./chunk-RQ3KKMTP.cjs');
-
-
-
-
-
-
-var _chunk4MMMEDQ7cjs = require('./chunk-4MMMEDQ7.cjs');
-
-// src/storage/sqlite/sqlite3/connections/connection.ts
-var _sqlite3 = require('sqlite3'); var _sqlite32 = _interopRequireDefault(_sqlite3);
-
-// src/storage/sqlite/core/connections/pragmas.ts
-var mergePragmaOptions = (connectionString, userOptions) => {
-  const connectionStringPragmas = _chunkJIZGCEPEcjs.parsePragmasFromConnectionString.call(void 0, connectionString);
-  return {
-    ..._chunkJIZGCEPEcjs.DEFAULT_SQLITE_PRAGMA_OPTIONS,
-    ...connectionStringPragmas,
-    ...userOptions
-  };
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+const require_core = require('./core-D-smW7cm.cjs');
+const require_sqliteMetadata = require('./sqliteMetadata-PJTRPIZ1.cjs');
+const require_core$1 = require('./core-CWZb0zOY.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 buildConnectionPragmaStatements = (pragmas) => [
-  // busy_timeout FIRST - enables waiting on locks for subsequent operations
-  { 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 }] : []
-];
-var buildDatabasePragmaStatements = (pragmas) => [
-  { pragma: "journal_mode", value: pragmas.journal_mode }
+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
+	}] : []
 ];
-
-// src/storage/sqlite/sqlite3/connections/connection.ts
-var SQLite3DriverType = "SQLite:sqlite3";
-var hasReturningClause = (sql) => /\bRETURNING\b/i.test(sql);
-var applyPragma = (database, pragma, value) => {
-  return new Promise((resolve, reject) => {
-    database.run(`PRAGMA ${pragma} = ${value};`, (err) => {
-      if (err) reject(err);
-      else resolve();
-    });
-  });
+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 queryPragma = (database, pragma) => new Promise((resolve, reject) => {
-  database.get(
-    `PRAGMA ${pragma};`,
-    (err, row) => {
-      if (err) reject(err);
-      else resolve(_nullishCoalesce(_optionalChain([row, 'optionalAccess', _ => _[pragma]]), () => ( "")));
-    }
-  );
+const queryPragma = (database, pragma) => new Promise((resolve, reject) => {
+	database.get(`PRAGMA ${pragma};`, (err, row) => {
+		if (err) reject(err);
+		else resolve(row?.[pragma] ?? "");
+	});
 });
-var applyPragmas = (database, pragmas) => pragmas.reduce(
-  (promise, { pragma, value }) => promise.then(() => applyPragma(database, pragma, value)),
-  Promise.resolve()
-);
-var sqlite3Client = (options) => {
-  let db;
-  let isClosed = false;
-  const { serializer } = options;
-  const connectionString = _nullishCoalesce(_nullishCoalesce(options.fileName, () => ( options.connectionString)), () => ( _chunkJIZGCEPEcjs.InMemorySQLiteDatabase));
-  const finalPragmas = mergePragmaOptions(
-    String(connectionString),
-    options.pragmaOptions
-  );
-  const connectionPragmas = buildConnectionPragmaStatements(finalPragmas);
-  const connect = () => db ? Promise.resolve() : new Promise((resolve, reject) => {
-    try {
-      db = new _sqlite32.default.Database(
-        connectionString,
-        _sqlite32.default.OPEN_URI | _sqlite32.default.OPEN_READWRITE | _sqlite32.default.OPEN_CREATE,
-        (err) => {
-          if (err) {
-            reject(err);
-            return;
-          }
-          const busyTimeout = _nullishCoalesce(finalPragmas.busy_timeout, () => ( _chunkJIZGCEPEcjs.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) {
-              const current = await queryPragma(db, pragma);
-              if (current.toUpperCase() !== String(value).toUpperCase()) {
-                await applyPragma(db, pragma, value);
-              }
-            }
-          }).then(() => resolve()).catch(reject);
-        }
-      );
-    } 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', _2 => _2.ignoreChangesCount]) === true) {
-        db.run(
-          sql,
-          _nullishCoalesce(params, () => ( [])),
-          function(err, rows) {
-            if (err) {
-              reject(err);
-              return;
-            }
-            resolve({
-              rowCount: 0,
-              rows: _nullishCoalesce(rows, () => ( []))
-            });
-          }
-        );
-        return;
-      }
-      if (hasReturningClause(sql)) {
-        db.all(sql, _nullishCoalesce(params, () => ( [])), (err, rows) => {
-          if (err) return reject(err);
-          resolve({ rowCount: rows.length, rows });
-        });
-        return;
-      }
-      db.serialize(() => {
-        let hasFailed = false;
-        let resultRows = [];
-        db.all(sql, _nullishCoalesce(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: _nullishCoalesce(_optionalChain([row, 'optionalAccess', _3 => _3.changes]), () => ( 0)),
-              rows: resultRows
-            });
-          }
-        );
-      });
-    } catch (error) {
-      reject(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 _chunkJIZGCEPEcjs.mapSqliteError.call(void 0, error);
-        }
-      }
-    },
-    query: async (sql, _options) => {
-      try {
-        const { query, params } = _chunkJIZGCEPEcjs.sqliteFormatter.format(sql, {
-          serializer
-        });
-        const result = await executeQuery(
-          query,
-          params
-        );
-        return { rowCount: result.length, rows: result };
-      } catch (error) {
-        throw _chunkJIZGCEPEcjs.mapSqliteError.call(void 0, error);
-      }
-    },
-    batchQuery: async (sqls, _options) => {
-      try {
-        const results = [];
-        for (const sql of sqls) {
-          const { query, params } = _chunkJIZGCEPEcjs.sqliteFormatter.format(sql, {
-            serializer
-          });
-          const result = await executeQuery(
-            query,
-            params
-          );
-          results.push({ rowCount: result.length, rows: result });
-        }
-        return results;
-      } catch (error) {
-        throw _chunkJIZGCEPEcjs.mapSqliteError.call(void 0, error);
-      }
-    },
-    command: async (sql, options2) => {
-      try {
-        const { query, params } = _chunkJIZGCEPEcjs.sqliteFormatter.format(sql, {
-          serializer
-        });
-        return await executeCommand(
-          query,
-          params,
-          options2
-        );
-      } catch (error) {
-        throw _chunkJIZGCEPEcjs.mapSqliteError.call(void 0, error);
-      }
-    },
-    batchCommand: async (sqls, options2) => {
-      try {
-        const results = [];
-        for (let i = 0; i < sqls.length; i++) {
-          const { query, params } = _chunkJIZGCEPEcjs.sqliteFormatter.format(sqls[i], {
-            serializer
-          });
-          const result = await executeCommand(
-            query,
-            params,
-            options2
-          );
-          results.push(result);
-          if (_optionalChain([options2, 'optionalAccess', _4 => _4.assertChanges]) && (_nullishCoalesce(result.rowCount, () => ( 0))) === 0) {
-            throw new (0, _chunk4MMMEDQ7cjs.BatchCommandNoChangesError)(i);
-          }
-        }
-        return results;
-      } catch (error) {
-        throw _chunkJIZGCEPEcjs.mapSqliteError.call(void 0, error);
-      }
-    }
-  };
+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 checkConnection = async (fileName, serializer) => {
-  const client = sqlite3Client({
-    fileName,
-    serializer
-  });
-  try {
-    await client.query(_chunk4MMMEDQ7cjs.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 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();
+	}
 };
-var sqlite3Connection = (options) => _chunkJIZGCEPEcjs.sqliteConnection.call(void 0, {
-  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
+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
 });
 
-// src/storage/sqlite/sqlite3/index.ts
-var sqlite3Pool = (options) => _chunkJIZGCEPEcjs.sqlitePool.call(void 0, 
-  _chunkJIZGCEPEcjs.toSqlitePoolOptions.call(void 0, {
-    ...options,
-    driverType: SQLite3DriverType,
-    ..."connection" in options ? {} : {
-      connectionOptions: options,
-      sqliteConnectionFactory: (opts) => sqlite3Connection({
-        ...opts,
-        serializer: _nullishCoalesce(options.serializer, () => ( _chunk4MMMEDQ7cjs.JSONSerializer))
-      })
-    }
-  })
-);
-var tryParseConnectionString = (connectionString) => {
-  try {
-    return _chunkJIZGCEPEcjs.SQLiteConnectionString.call(void 0, connectionString);
-  } catch (e) {
-    return null;
-  }
+//#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();
+		}
+	};
 };
-var sqlite3DumboDriver = {
-  driverType: SQLite3DriverType,
-  createPool: (options) => sqlite3Pool(options),
-  sqlFormatter: _chunkJIZGCEPEcjs.sqliteFormatter,
-  defaultMigratorOptions: _chunkJIZGCEPEcjs.DefaultSQLiteMigratorOptions,
-  canHandle: _chunk4MMMEDQ7cjs.canHandleDriverWithConnectionString.call(void 0, 
-    SQLite3DriverType,
-    tryParseConnectionString
-  ),
-  databaseMetadata: _chunkRQ3KKMTPcjs.sqliteMetadata
+
+//#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()]);
+		}
+	};
 };
-var useSqlite3DumboDriver = () => {
-  _chunk4MMMEDQ7cjs.dumboDatabaseDriverRegistry.register(SQLite3DriverType, sqlite3DumboDriver);
+
+//#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();
 
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-exports.DEFAULT_SQLITE_PRAGMA_OPTIONS = _chunkJIZGCEPEcjs.DEFAULT_SQLITE_PRAGMA_OPTIONS; exports.DefaultSQLiteMigratorOptions = _chunkJIZGCEPEcjs.DefaultSQLiteMigratorOptions; exports.InMemorySQLiteDatabase = _chunkJIZGCEPEcjs.InMemorySQLiteDatabase; exports.SQLite3DriverType = SQLite3DriverType; exports.SQLiteConnectionString = _chunkJIZGCEPEcjs.SQLiteConnectionString; exports.SQLiteDatabaseName = _chunkJIZGCEPEcjs.SQLiteDatabaseName; exports.checkConnection = checkConnection; exports.defaultSQLiteDatabase = _chunkRQ3KKMTPcjs.defaultSQLiteDatabase; exports.isInMemoryDatabase = _chunkJIZGCEPEcjs.isInMemoryDatabase; exports.isSQLiteError = _chunkJIZGCEPEcjs.isSQLiteError; exports.mapSqliteError = _chunkJIZGCEPEcjs.mapSqliteError; exports.parsePragmasFromConnectionString = _chunkJIZGCEPEcjs.parsePragmasFromConnectionString; exports.sqlite3Client = sqlite3Client; exports.sqlite3Connection = sqlite3Connection; exports.sqlite3DumboDriver = sqlite3DumboDriver; exports.sqlite3Pool = sqlite3Pool; exports.sqliteAlwaysNewConnectionPool = _chunkJIZGCEPEcjs.sqliteAlwaysNewConnectionPool; exports.sqliteAmbientClientConnection = _chunkJIZGCEPEcjs.sqliteAmbientClientConnection; exports.sqliteAmbientConnectionPool = _chunkJIZGCEPEcjs.sqliteAmbientConnectionPool; exports.sqliteClientConnection = _chunkJIZGCEPEcjs.sqliteClientConnection; exports.sqliteConnection = _chunkJIZGCEPEcjs.sqliteConnection; exports.sqliteExecute = _chunkJIZGCEPEcjs.sqliteExecute; exports.sqliteFormatter = _chunkJIZGCEPEcjs.sqliteFormatter; exports.sqliteMetadata = _chunkRQ3KKMTPcjs.sqliteMetadata; exports.sqlitePool = _chunkJIZGCEPEcjs.sqlitePool; exports.sqlitePoolClientConnection = _chunkJIZGCEPEcjs.sqlitePoolClientConnection; exports.sqliteSQLExecutor = _chunkJIZGCEPEcjs.sqliteSQLExecutor; exports.sqliteSingletonConnectionPool = _chunkJIZGCEPEcjs.sqliteSingletonConnectionPool; exports.sqliteTransaction = _chunkJIZGCEPEcjs.sqliteTransaction; exports.tableExists = _chunkRQ3KKMTPcjs.tableExists; exports.toSqlitePoolOptions = _chunkJIZGCEPEcjs.toSqlitePoolOptions; exports.transactionNestingCounter = _chunkJIZGCEPEcjs.transactionNestingCounter; exports.useSqlite3DumboDriver = 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