@event-driven-io/dumbo 0.13.0-beta.43 → 0.13.0-beta.44

package/dist/cloudflare.d.cts

@@ -897,9 +897,12 @@ type InitTransaction<ConnectionType extends AnyConnection = AnyConnection> = (co
 }) => InferTransactionFromConnection<ConnectionType>;
 //#endregion
 //#region src/core/connections/pool.d.ts
+type PoolCloseOptions = {
+  force?: boolean;
+};
 interface ConnectionPool<ConnectionType extends AnyConnection = AnyConnection> extends WithSQLExecutor, WithConnectionFactory<ConnectionType>, WithDatabaseTransactionFactory<ConnectionType> {
   driverType: ConnectionType['driverType'];
-  close: () => Promise<void>;
+  close: (options?: PoolCloseOptions) => Promise<void>;
 }
 //#endregion
 //#region src/core/index.d.ts
@@ -990,13 +993,6 @@ type SQLitePoolConnectionDefinitionOptions<SQLiteConnectionType extends AnySQLit
 };
 type SQLiteConnectionDefinitionOptions<SQLiteConnectionType extends AnySQLitePoolClientConnection = AnySQLitePoolClientConnection, ClientOptions = SQLiteClientOptions> = SQLiteClientConnectionDefinitionOptions<SQLiteConnectionType, ClientOptions> | SQLitePoolConnectionDefinitionOptions<SQLiteConnectionType, ClientOptions>;
 type SQLiteConnectionFactory<SQLiteConnectionType extends AnySQLiteConnection = AnySQLiteConnection, ConnectionOptions extends SQLiteConnectionOptions = SQLiteConnectionOptions> = (options: ConnectionOptions) => SQLiteConnectionType;
-type TransactionNestingCounter = {
-  increment: () => void;
-  decrement: () => void;
-  reset: () => void;
-  level: number;
-};
-declare const transactionNestingCounter: () => TransactionNestingCounter;
 type SqliteAmbientClientConnectionOptions<SQLiteConnectionType extends AnySQLiteClientConnection = AnySQLiteClientConnection> = {
   driverType: SQLiteConnectionType['driverType'];
   client: InferDbClientFromConnection<SQLiteConnectionType>;
@@ -1198,5 +1194,5 @@ type D1DumboConnectionOptions = DumboConnectionOptions<typeof d1DumboDriver> & {
   database: D1Database;
 };
 //#endregion
-export { AnySQLiteClientConnection, AnySQLiteConnection, AnySQLitePoolClientConnection, BatchSQLiteCommandOptions, D1Client, D1ClientOptions, D1Connection, D1ConnectionOptions, D1ConnectionPool, D1DatabaseOrSession, D1DriverType, D1DumboConnectionOptions, D1DumboOptions, D1PoolOptions, D1SessionOptions, D1Transaction, D1TransactionMode, D1TransactionNotSupportedError, D1TransactionOptions, DEFAULT_SQLITE_PRAGMA_OPTIONS, DefaultSQLiteMigratorOptions, InMemorySQLiteDatabase, SQLiteAlwaysNewConnectionPool, SQLiteAmbientConnectionPool, SQLiteClient, SQLiteClientConnection, SQLiteClientConnectionDefinitionOptions, SQLiteClientFactory, SQLiteClientOptions, SQLiteClientOrPoolClient, SQLiteCommandOptions, SQLiteConnection, SQLiteConnectionDefinitionOptions, SQLiteConnectionFactory, SQLiteConnectionOptions, SQLiteConnectionString, SQLiteDatabaseName, SQLiteDatabaseType, SQLiteDriverType, SQLiteError, SQLiteErrorMapper, SQLiteFileNameOrConnectionString, SQLiteJSON, SQLiteParameters, SQLitePool, SQLitePoolClient, SQLitePoolClientConnection, SQLitePoolConnectionDefinitionOptions, SQLitePoolFactoryOptions, SQLitePoolOptions, type SQLitePragmaOptions, SQLiteSQLExecutor, SQLiteSingletonConnectionPool, SQLiteTransaction, SQLiteTransactionMode, SQLiteTransactionOptions, SqliteAmbientClientConnectionOptions, TransactionNestingCounter, d1Client, d1Connection, d1DumboDriver, d1Pool, d1SQLExecutor, d1Transaction, defaultSQLiteDatabase, isInMemoryDatabase, isSQLiteError, mapD1Error, mapSqliteError, parsePragmasFromConnectionString, sqliteAlwaysNewConnectionPool, sqliteAmbientClientConnection, sqliteAmbientConnectionPool, sqliteClientConnection, sqliteConnection, sqliteExecute, sqliteFormatter, sqliteMetadata, sqlitePool, sqlitePoolClientConnection, sqliteSQLExecutor, sqliteSingletonConnectionPool, sqliteTransaction, tableExists, toSqlitePoolOptions, transactionNestingCounter, useD1DumboDriver };
+export { AnySQLiteClientConnection, AnySQLiteConnection, AnySQLitePoolClientConnection, BatchSQLiteCommandOptions, D1Client, D1ClientOptions, D1Connection, D1ConnectionOptions, D1ConnectionPool, D1DatabaseOrSession, D1DriverType, D1DumboConnectionOptions, D1DumboOptions, D1PoolOptions, D1SessionOptions, D1Transaction, D1TransactionMode, D1TransactionNotSupportedError, D1TransactionOptions, DEFAULT_SQLITE_PRAGMA_OPTIONS, DefaultSQLiteMigratorOptions, InMemorySQLiteDatabase, SQLiteAlwaysNewConnectionPool, SQLiteAmbientConnectionPool, SQLiteClient, SQLiteClientConnection, SQLiteClientConnectionDefinitionOptions, SQLiteClientFactory, SQLiteClientOptions, SQLiteClientOrPoolClient, SQLiteCommandOptions, SQLiteConnection, SQLiteConnectionDefinitionOptions, SQLiteConnectionFactory, SQLiteConnectionOptions, SQLiteConnectionString, SQLiteDatabaseName, SQLiteDatabaseType, SQLiteDriverType, SQLiteError, SQLiteErrorMapper, SQLiteFileNameOrConnectionString, SQLiteJSON, SQLiteParameters, SQLitePool, SQLitePoolClient, SQLitePoolClientConnection, SQLitePoolConnectionDefinitionOptions, SQLitePoolFactoryOptions, SQLitePoolOptions, type SQLitePragmaOptions, SQLiteSQLExecutor, SQLiteSingletonConnectionPool, SQLiteTransaction, SQLiteTransactionMode, SQLiteTransactionOptions, SqliteAmbientClientConnectionOptions, d1Client, d1Connection, d1DumboDriver, d1Pool, d1SQLExecutor, d1Transaction, defaultSQLiteDatabase, isInMemoryDatabase, isSQLiteError, mapD1Error, mapSqliteError, parsePragmasFromConnectionString, sqliteAlwaysNewConnectionPool, sqliteAmbientClientConnection, sqliteAmbientConnectionPool, sqliteClientConnection, sqliteConnection, sqliteExecute, sqliteFormatter, sqliteMetadata, sqlitePool, sqlitePoolClientConnection, sqliteSQLExecutor, sqliteSingletonConnectionPool, sqliteTransaction, tableExists, toSqlitePoolOptions, useD1DumboDriver };
 //# sourceMappingURL=cloudflare.d.cts.map

package/dist/cloudflare.d.ts

@@ -897,9 +897,12 @@ type InitTransaction<ConnectionType extends AnyConnection = AnyConnection> = (co
 }) => InferTransactionFromConnection<ConnectionType>;
 //#endregion
 //#region src/core/connections/pool.d.ts
+type PoolCloseOptions = {
+  force?: boolean;
+};
 interface ConnectionPool<ConnectionType extends AnyConnection = AnyConnection> extends WithSQLExecutor, WithConnectionFactory<ConnectionType>, WithDatabaseTransactionFactory<ConnectionType> {
   driverType: ConnectionType['driverType'];
-  close: () => Promise<void>;
+  close: (options?: PoolCloseOptions) => Promise<void>;
 }
 //#endregion
 //#region src/core/index.d.ts
@@ -990,13 +993,6 @@ type SQLitePoolConnectionDefinitionOptions<SQLiteConnectionType extends AnySQLit
 };
 type SQLiteConnectionDefinitionOptions<SQLiteConnectionType extends AnySQLitePoolClientConnection = AnySQLitePoolClientConnection, ClientOptions = SQLiteClientOptions> = SQLiteClientConnectionDefinitionOptions<SQLiteConnectionType, ClientOptions> | SQLitePoolConnectionDefinitionOptions<SQLiteConnectionType, ClientOptions>;
 type SQLiteConnectionFactory<SQLiteConnectionType extends AnySQLiteConnection = AnySQLiteConnection, ConnectionOptions extends SQLiteConnectionOptions = SQLiteConnectionOptions> = (options: ConnectionOptions) => SQLiteConnectionType;
-type TransactionNestingCounter = {
-  increment: () => void;
-  decrement: () => void;
-  reset: () => void;
-  level: number;
-};
-declare const transactionNestingCounter: () => TransactionNestingCounter;
 type SqliteAmbientClientConnectionOptions<SQLiteConnectionType extends AnySQLiteClientConnection = AnySQLiteClientConnection> = {
   driverType: SQLiteConnectionType['driverType'];
   client: InferDbClientFromConnection<SQLiteConnectionType>;
@@ -1198,5 +1194,5 @@ type D1DumboConnectionOptions = DumboConnectionOptions<typeof d1DumboDriver> & {
   database: D1Database;
 };
 //#endregion
-export { AnySQLiteClientConnection, AnySQLiteConnection, AnySQLitePoolClientConnection, BatchSQLiteCommandOptions, D1Client, D1ClientOptions, D1Connection, D1ConnectionOptions, D1ConnectionPool, D1DatabaseOrSession, D1DriverType, D1DumboConnectionOptions, D1DumboOptions, D1PoolOptions, D1SessionOptions, D1Transaction, D1TransactionMode, D1TransactionNotSupportedError, D1TransactionOptions, DEFAULT_SQLITE_PRAGMA_OPTIONS, DefaultSQLiteMigratorOptions, InMemorySQLiteDatabase, SQLiteAlwaysNewConnectionPool, SQLiteAmbientConnectionPool, SQLiteClient, SQLiteClientConnection, SQLiteClientConnectionDefinitionOptions, SQLiteClientFactory, SQLiteClientOptions, SQLiteClientOrPoolClient, SQLiteCommandOptions, SQLiteConnection, SQLiteConnectionDefinitionOptions, SQLiteConnectionFactory, SQLiteConnectionOptions, SQLiteConnectionString, SQLiteDatabaseName, SQLiteDatabaseType, SQLiteDriverType, SQLiteError, SQLiteErrorMapper, SQLiteFileNameOrConnectionString, SQLiteJSON, SQLiteParameters, SQLitePool, SQLitePoolClient, SQLitePoolClientConnection, SQLitePoolConnectionDefinitionOptions, SQLitePoolFactoryOptions, SQLitePoolOptions, type SQLitePragmaOptions, SQLiteSQLExecutor, SQLiteSingletonConnectionPool, SQLiteTransaction, SQLiteTransactionMode, SQLiteTransactionOptions, SqliteAmbientClientConnectionOptions, TransactionNestingCounter, d1Client, d1Connection, d1DumboDriver, d1Pool, d1SQLExecutor, d1Transaction, defaultSQLiteDatabase, isInMemoryDatabase, isSQLiteError, mapD1Error, mapSqliteError, parsePragmasFromConnectionString, sqliteAlwaysNewConnectionPool, sqliteAmbientClientConnection, sqliteAmbientConnectionPool, sqliteClientConnection, sqliteConnection, sqliteExecute, sqliteFormatter, sqliteMetadata, sqlitePool, sqlitePoolClientConnection, sqliteSQLExecutor, sqliteSingletonConnectionPool, sqliteTransaction, tableExists, toSqlitePoolOptions, transactionNestingCounter, useD1DumboDriver };
+export { AnySQLiteClientConnection, AnySQLiteConnection, AnySQLitePoolClientConnection, BatchSQLiteCommandOptions, D1Client, D1ClientOptions, D1Connection, D1ConnectionOptions, D1ConnectionPool, D1DatabaseOrSession, D1DriverType, D1DumboConnectionOptions, D1DumboOptions, D1PoolOptions, D1SessionOptions, D1Transaction, D1TransactionMode, D1TransactionNotSupportedError, D1TransactionOptions, DEFAULT_SQLITE_PRAGMA_OPTIONS, DefaultSQLiteMigratorOptions, InMemorySQLiteDatabase, SQLiteAlwaysNewConnectionPool, SQLiteAmbientConnectionPool, SQLiteClient, SQLiteClientConnection, SQLiteClientConnectionDefinitionOptions, SQLiteClientFactory, SQLiteClientOptions, SQLiteClientOrPoolClient, SQLiteCommandOptions, SQLiteConnection, SQLiteConnectionDefinitionOptions, SQLiteConnectionFactory, SQLiteConnectionOptions, SQLiteConnectionString, SQLiteDatabaseName, SQLiteDatabaseType, SQLiteDriverType, SQLiteError, SQLiteErrorMapper, SQLiteFileNameOrConnectionString, SQLiteJSON, SQLiteParameters, SQLitePool, SQLitePoolClient, SQLitePoolClientConnection, SQLitePoolConnectionDefinitionOptions, SQLitePoolFactoryOptions, SQLitePoolOptions, type SQLitePragmaOptions, SQLiteSQLExecutor, SQLiteSingletonConnectionPool, SQLiteTransaction, SQLiteTransactionMode, SQLiteTransactionOptions, SqliteAmbientClientConnectionOptions, d1Client, d1Connection, d1DumboDriver, d1Pool, d1SQLExecutor, d1Transaction, defaultSQLiteDatabase, isInMemoryDatabase, isSQLiteError, mapD1Error, mapSqliteError, parsePragmasFromConnectionString, sqliteAlwaysNewConnectionPool, sqliteAmbientClientConnection, sqliteAmbientConnectionPool, sqliteClientConnection, sqliteConnection, sqliteExecute, sqliteFormatter, sqliteMetadata, sqlitePool, sqlitePoolClientConnection, sqliteSQLExecutor, sqliteSingletonConnectionPool, sqliteTransaction, tableExists, toSqlitePoolOptions, useD1DumboDriver };
 //# sourceMappingURL=cloudflare.d.ts.map

package/dist/cloudflare.js

@@ -240,6 +240,65 @@ const executeInAmbientConnection = async (handle, options) => {
 
 //#endregion
 //#region src/core/connections/transaction.ts
+const transactionNestingCounter = () => {
+	let transactionLevel = 0;
+	return {
+		reset: () => {
+			transactionLevel = 0;
+		},
+		increment: () => {
+			transactionLevel++;
+		},
+		decrement: () => {
+			transactionLevel--;
+			if (transactionLevel < 0) throw new Error("Transaction level is out of bounds");
+		},
+		get level() {
+			return transactionLevel;
+		}
+	};
+};
+const databaseTransaction = (backend, options) => {
+	const allowNestedTransactions = options?.allowNestedTransactions ?? false;
+	const useSavepoints = options?.useSavepoints ?? false;
+	const counter = transactionNestingCounter();
+	let hasBegun = false;
+	return {
+		begin: async () => {
+			if (!allowNestedTransactions && hasBegun) throw new InvalidOperationError("Cannot start a nested transaction: allowNestedTransactions is false. Set transactionOptions: { allowNestedTransactions: true } on your pool or connection.");
+			if (allowNestedTransactions) {
+				if (counter.level >= 1) {
+					counter.increment();
+					if (useSavepoints && backend.savepoint) await backend.savepoint(counter.level);
+					return;
+				}
+				counter.increment();
+			}
+			hasBegun = true;
+			await backend.begin();
+		},
+		commit: async () => {
+			if (allowNestedTransactions && counter.level > 1) {
+				if (useSavepoints && backend.releaseSavepoint) await backend.releaseSavepoint(counter.level);
+				counter.decrement();
+				return;
+			}
+			if (allowNestedTransactions) counter.reset();
+			hasBegun = false;
+			await backend.commit();
+		},
+		rollback: async (error) => {
+			if (allowNestedTransactions && counter.level > 1) {
+				if (useSavepoints && backend.rollbackToSavepoint) await backend.rollbackToSavepoint(counter.level);
+				counter.decrement();
+				return;
+			}
+			if (allowNestedTransactions) counter.reset();
+			hasBegun = false;
+			await backend.rollback(error);
+		}
+	};
+};
 const toTransactionResult = (transactionResult) => transactionResult !== void 0 && transactionResult !== null && typeof transactionResult === "object" && "success" in transactionResult ? transactionResult : {
 	success: true,
 	result: transactionResult
@@ -430,22 +489,53 @@ const createAmbientConnectionPool = (options) => {
 const createSingletonConnectionPool = (options) => {
 	const { driverType, getConnection } = options;
 	let connectionPromise = null;
+	let closed = false;
+	const activeOperations = /* @__PURE__ */ new Set();
+	const closedError = () => /* @__PURE__ */ new Error("Singleton connection pool has been closed");
+	const run = async (operation) => {
+		if (closed) throw closedError();
+		const activeOperation = operation();
+		activeOperations.add(activeOperation);
+		try {
+			return await activeOperation;
+		} finally {
+			activeOperations.delete(activeOperation);
+		}
+	};
 	const getExistingOrNewConnection = () => {
 		if (!connectionPromise) connectionPromise ??= Promise.resolve(getConnection());
 		return connectionPromise;
 	};
+	const innerTransactionFactory = transactionFactoryWithAsyncAmbientConnection(options.driverType, getExistingOrNewConnection, options.closeConnection);
 	return {
 		driverType,
-		connection: () => getExistingOrNewConnection().then((conn) => wrapPooledConnection(conn, () => Promise.resolve())),
-		execute: sqlExecutorInAmbientConnection({
-			driverType,
-			connection: getExistingOrNewConnection
-		}),
-		withConnection: (handle, _options) => executeInAmbientConnection(handle, { connection: getExistingOrNewConnection }),
-		...transactionFactoryWithAsyncAmbientConnection(options.driverType, getExistingOrNewConnection, options.closeConnection),
-		close: async () => {
+		connection: () => run(() => getExistingOrNewConnection().then((conn) => wrapPooledConnection(conn, () => Promise.resolve()))),
+		execute: (() => {
+			const ambientExecutor = sqlExecutorInAmbientConnection({
+				driverType,
+				connection: getExistingOrNewConnection
+			});
+			return {
+				query: (sql, opts) => run(() => ambientExecutor.query(sql, opts)),
+				batchQuery: (sqls, opts) => run(() => ambientExecutor.batchQuery(sqls, opts)),
+				command: (sql, opts) => run(() => ambientExecutor.command(sql, opts)),
+				batchCommand: (sqls, opts) => run(() => ambientExecutor.batchCommand(sqls, opts))
+			};
+		})(),
+		withConnection: (handle, _options) => run(() => executeInAmbientConnection(handle, { connection: getExistingOrNewConnection })),
+		transaction: (transactionOptions) => {
+			if (closed) throw closedError();
+			return innerTransactionFactory.transaction(transactionOptions);
+		},
+		withTransaction: (handle, transactionOptions) => run(() => innerTransactionFactory.withTransaction(handle, transactionOptions)),
+		close: async (closeOptions) => {
+			if (closed) return;
+			closed = true;
+			if (!closeOptions?.force) await Promise.allSettled([...activeOperations]);
 			if (!connectionPromise) return;
-			await (await connectionPromise).close();
+			const connection = await connectionPromise;
+			connectionPromise = null;
+			await connection.close();
 		}
 	};
 };
@@ -1798,54 +1888,46 @@ const sqliteSQLExecutor = (driverType, serializer, formatter, errorMapper) => ({
 //#endregion
 //#region src/storage/sqlite/core/transactions/index.ts
 const sqliteTransaction = (driverType, connection, allowNestedTransactions, serializer, defaultTransactionMode) => (getClient, options) => {
-	const transactionCounter = transactionNestingCounter();
 	allowNestedTransactions = options?.allowNestedTransactions ?? allowNestedTransactions;
-	let hasBegun = false;
-	return {
-		connection: connection(),
-		driverType,
-		begin: async function() {
+	const useSavepoints = options?.useSavepoints ?? false;
+	const tx = databaseTransaction({
+		begin: async () => {
 			const client = await getClient;
-			if (allowNestedTransactions) {
-				if (transactionCounter.level >= 1) {
-					transactionCounter.increment();
-					if (options?.useSavepoints) await client.command(SQL`SAVEPOINT transaction${SQL.plain(transactionCounter.level.toString())}`);
-					return;
-				}
-				transactionCounter.increment();
-			} else if (hasBegun) throw new InvalidOperationError("Cannot start a nested transaction: allowNestedTransactions is false. Set transactionOptions: { allowNestedTransactions: true } on your pool or connection.");
-			hasBegun = true;
 			const mode = options?.mode ?? defaultTransactionMode ?? "IMMEDIATE";
 			await client.command(SQL`BEGIN ${SQL.plain(mode)} TRANSACTION`);
 		},
-		commit: async function() {
+		commit: async () => {
 			const client = await getClient;
-			if (allowNestedTransactions && transactionCounter.level > 1) {
-				if (options?.useSavepoints) await client.command(SQL`RELEASE transaction${SQL.plain(transactionCounter.level.toString())}`);
-				transactionCounter.decrement();
-				return;
-			}
 			try {
-				if (allowNestedTransactions) transactionCounter.reset();
-				hasBegun = false;
 				await client.command(SQL`COMMIT`);
 			} finally {
-				if (options?.close) await options?.close(client);
+				if (options?.close) await options.close(client);
 			}
 		},
-		rollback: async function(error) {
+		rollback: async (error) => {
 			const client = await getClient;
-			if (allowNestedTransactions && transactionCounter.level > 1) {
-				transactionCounter.decrement();
-				return;
-			}
 			try {
-				hasBegun = false;
 				await client.command(SQL`ROLLBACK`);
 			} finally {
-				if (options?.close) await options?.close(client, error);
+				if (options?.close) await options.close(client, error);
 			}
 		},
+		savepoint: async (level) => {
+			await (await getClient).command(SQL`SAVEPOINT transaction${SQL.plain(level.toString())}`);
+		},
+		releaseSavepoint: async (level) => {
+			await (await getClient).command(SQL`RELEASE transaction${SQL.plain(level.toString())}`);
+		}
+	}, {
+		allowNestedTransactions,
+		useSavepoints
+	});
+	return {
+		connection: connection(),
+		driverType,
+		begin: tx.begin,
+		commit: tx.commit,
+		rollback: tx.rollback,
 		execute: sqlExecutor(sqliteSQLExecutor(driverType, serializer), { connect: () => getClient }),
 		_transactionOptions: {
 			...options,
@@ -1891,24 +1973,6 @@ const isSQLiteError = (error) => {
 	if (error instanceof Error && "code" in error) return true;
 	return false;
 };
-const transactionNestingCounter = () => {
-	let transactionLevel = 0;
-	return {
-		reset: () => {
-			transactionLevel = 0;
-		},
-		increment: () => {
-			transactionLevel++;
-		},
-		decrement: () => {
-			transactionLevel--;
-			if (transactionLevel < 0) throw new Error("Transaction level is out of bounds");
-		},
-		get level() {
-			return transactionLevel;
-		}
-	};
-};
 const sqliteAmbientClientConnection = (options) => {
 	const { client, driverType, initTransaction, allowNestedTransactions, defaultTransactionMode, serializer, errorMapper } = options;
 	return createAmbientConnection({
@@ -2436,5 +2500,5 @@ const useD1DumboDriver = () => {
 useD1DumboDriver();
 
 //#endregion
-export { D1DriverType, D1TransactionNotSupportedError, DEFAULT_SQLITE_PRAGMA_OPTIONS, DefaultSQLiteMigratorOptions, InMemorySQLiteDatabase, SQLiteConnectionString, SQLiteDatabaseName, SQLiteJSON, d1Client, d1Connection, d1DumboDriver, d1Pool, d1SQLExecutor, d1Transaction, defaultSQLiteDatabase, isInMemoryDatabase, isSQLiteError, mapD1Error, mapSqliteError, parsePragmasFromConnectionString, sqliteAlwaysNewConnectionPool, sqliteAmbientClientConnection, sqliteAmbientConnectionPool, sqliteClientConnection, sqliteConnection, sqliteExecute, sqliteFormatter, sqliteMetadata, sqlitePool, sqlitePoolClientConnection, sqliteSQLExecutor, sqliteSingletonConnectionPool, sqliteTransaction, tableExists, toSqlitePoolOptions, transactionNestingCounter, useD1DumboDriver };
+export { D1DriverType, D1TransactionNotSupportedError, DEFAULT_SQLITE_PRAGMA_OPTIONS, DefaultSQLiteMigratorOptions, InMemorySQLiteDatabase, SQLiteConnectionString, SQLiteDatabaseName, SQLiteJSON, d1Client, d1Connection, d1DumboDriver, d1Pool, d1SQLExecutor, d1Transaction, defaultSQLiteDatabase, isInMemoryDatabase, isSQLiteError, mapD1Error, mapSqliteError, parsePragmasFromConnectionString, sqliteAlwaysNewConnectionPool, sqliteAmbientClientConnection, sqliteAmbientConnectionPool, sqliteClientConnection, sqliteConnection, sqliteExecute, sqliteFormatter, sqliteMetadata, sqlitePool, sqlitePoolClientConnection, sqliteSQLExecutor, sqliteSingletonConnectionPool, sqliteTransaction, tableExists, toSqlitePoolOptions, useD1DumboDriver };
 //# sourceMappingURL=cloudflare.js.map