@event-driven-io/dumbo 0.13.0-beta.34 → 0.13.0-beta.36

package/dist/core-DmbB4qMn.cjs

@@ -0,0 +1,656 @@
+const require_core = require('./core-BgYtAxCm.cjs');
+require('./sqliteMetadata-D_2pKeCC.cjs');
+let os = require("os");
+
+//#region src/storage/sqlite/core/errors/errorMapper.ts
+/**
+* Extracts the SQLite error code string from a `sqlite3` driver error.
+*
+* The `sqlite3` (node-sqlite3) driver sets `error.code` to a string like
+* `'SQLITE_CONSTRAINT'` and `error.errno` to the numeric result code.
+* See: https://github.com/TryGhost/node-sqlite3
+*/
+const getSqliteErrorCode = (error) => {
+	if (error instanceof Error && "code" in error && typeof error.code === "string") return error.code;
+};
+const getErrorMessage = (error) => error instanceof Error ? error.message : void 0;
+const asError = (error) => error instanceof Error ? error : void 0;
+/**
+* Maps a constraint error to a specific DumboError subtype by inspecting the
+* error message. The `sqlite3` driver only exposes the primary result code
+* `SQLITE_CONSTRAINT` — the constraint subtype (UNIQUE, FOREIGN KEY, etc.)
+* is embedded in the message string by SQLite, e.g.:
+*   "SQLITE_CONSTRAINT: UNIQUE constraint failed: users.email"
+*
+* Reference: https://www.sqlite.org/rescode.html (extended result codes 275–3091)
+*/
+const mapConstraintError = (message, innerError) => {
+	const upperMessage = message?.toUpperCase() ?? "";
+	if (upperMessage.includes("UNIQUE") || upperMessage.includes("PRIMARY KEY")) return new require_core.UniqueConstraintError(message, innerError);
+	if (upperMessage.includes("FOREIGN KEY")) return new require_core.ForeignKeyViolationError(message, innerError);
+	if (upperMessage.includes("NOT NULL")) return new require_core.NotNullViolationError(message, innerError);
+	if (upperMessage.includes("CHECK")) return new require_core.CheckViolationError(message, innerError);
+	return new require_core.IntegrityConstraintViolationError(message, innerError);
+};
+/**
+* Maps a SQLite error (from the `sqlite3` / node-sqlite3 driver) to a typed
+* DumboError based on the SQLite result code.
+*
+* Result code reference: https://www.sqlite.org/rescode.html
+*
+* Falls back to a generic DumboError (500) if the error is not a recognized SQLite error.
+*/
+const mapSqliteError = (error) => {
+	if (require_core.DumboError.isInstanceOf(error)) return error;
+	const code = getSqliteErrorCode(error);
+	if (!code) return new require_core.DumboError({
+		errorCode: 500,
+		message: getErrorMessage(error),
+		innerError: asError(error)
+	});
+	const message = getErrorMessage(error);
+	const innerError = asError(error);
+	switch (code) {
+		case "SQLITE_CONSTRAINT": return mapConstraintError(message, innerError);
+		case "SQLITE_BUSY": return new require_core.LockNotAvailableError(message, innerError);
+		case "SQLITE_LOCKED": return new require_core.DeadlockError(message, innerError);
+		case "SQLITE_PROTOCOL": return new require_core.LockNotAvailableError(message, innerError);
+		case "SQLITE_CANTOPEN": return new require_core.ConnectionError(message, innerError);
+		case "SQLITE_NOTADB": return new require_core.ConnectionError(message, innerError);
+		case "SQLITE_NOMEM": return new require_core.InsufficientResourcesError(message, innerError);
+		case "SQLITE_FULL": return new require_core.InsufficientResourcesError(message, innerError);
+		case "SQLITE_IOERR": return new require_core.SystemError(message, innerError);
+		case "SQLITE_CORRUPT": return new require_core.SystemError(message, innerError);
+		case "SQLITE_INTERNAL": return new require_core.SystemError(message, innerError);
+		case "SQLITE_NOLFS": return new require_core.SystemError(message, innerError);
+		case "SQLITE_TOOBIG": return new require_core.DataError(message, innerError);
+		case "SQLITE_MISMATCH": return new require_core.DataError(message, innerError);
+		case "SQLITE_RANGE": return new require_core.DataError(message, innerError);
+		case "SQLITE_ERROR": return new require_core.InvalidOperationError(message, innerError);
+		case "SQLITE_READONLY": return new require_core.InvalidOperationError(message, innerError);
+		case "SQLITE_MISUSE": return new require_core.InvalidOperationError(message, innerError);
+		case "SQLITE_AUTH": return new require_core.InvalidOperationError(message, innerError);
+		case "SQLITE_PERM": return new require_core.InvalidOperationError(message, innerError);
+		case "SQLITE_SCHEMA": return new require_core.InvalidOperationError(message, innerError);
+		case "SQLITE_ABORT": return new require_core.SerializationError(message, innerError);
+		case "SQLITE_INTERRUPT": return new require_core.SerializationError(message, innerError);
+	}
+	return new require_core.DumboError({
+		errorCode: 500,
+		message,
+		innerError
+	});
+};
+
+//#endregion
+//#region src/storage/sqlite/core/sql/processors/columProcessors.ts
+const mapColumnType = (token, { builder }) => {
+	let columnSQL;
+	const { sqlTokenType } = token;
+	switch (sqlTokenType) {
+		case "SQL_COLUMN_AUTO_INCREMENT":
+			columnSQL = `INTEGER ${token.primaryKey ? "PRIMARY KEY" : ""} AUTOINCREMENT`;
+			break;
+		case "SQL_COLUMN_BIGINT":
+			columnSQL = "INTEGER";
+			break;
+		case "SQL_COLUMN_SERIAL":
+			columnSQL = "INTEGER";
+			break;
+		case "SQL_COLUMN_INTEGER":
+			columnSQL = "INTEGER";
+			break;
+		case "SQL_COLUMN_JSONB":
+			columnSQL = "BLOB";
+			break;
+		case "SQL_COLUMN_BIGSERIAL":
+			columnSQL = "INTEGER";
+			break;
+		case "SQL_COLUMN_TIMESTAMP":
+			columnSQL = "DATETIME";
+			break;
+		case "SQL_COLUMN_TIMESTAMPTZ":
+			columnSQL = "DATETIME";
+			break;
+		case "SQL_COLUMN_VARCHAR":
+			columnSQL = `VARCHAR ${Number.isNaN(token.length) ? "" : `(${token.length})`}`;
+			break;
+		default: throw new Error(`Unknown column type: ${sqlTokenType}`);
+	}
+	builder.addSQL(columnSQL);
+};
+const sqliteColumnProcessors = require_core.mapDefaultSQLColumnProcessors(mapColumnType);
+
+//#endregion
+//#region src/storage/sqlite/core/sql/formatter/index.ts
+const sqliteFormatter = require_core.SQLFormatter({ processorsRegistry: require_core.SQLProcessorsRegistry({ from: require_core.defaultProcessorsRegistry }).register(sqliteColumnProcessors) });
+require_core.registerFormatter("SQLite", sqliteFormatter);
+
+//#endregion
+//#region src/storage/sqlite/core/execute/execute.ts
+const sqliteExecute = async (database, handle) => {
+	try {
+		return await handle(database);
+	} finally {
+		await database.close();
+	}
+};
+const sqliteSQLExecutor = (driverType, serializer, formatter, errorMapper) => ({
+	driverType,
+	query: async (client, sql, options) => {
+		require_core.tracer.info("db:sql:query", {
+			query: (formatter ?? sqliteFormatter).format(sql, { serializer }).query,
+			params: (formatter ?? sqliteFormatter).format(sql, { serializer }).params,
+			debugSQL: (formatter ?? sqliteFormatter).describe(sql, { serializer })
+		});
+		try {
+			let result = await client.query(sql, options);
+			if (options?.mapping) result = {
+				...result,
+				rows: result.rows.map((row) => require_core.mapSQLQueryResult(row, options.mapping))
+			};
+			return result;
+		} catch (error) {
+			require_core.tracer.error("db:sql:query:execute:error", { error });
+			throw (errorMapper ?? mapSqliteError)(error);
+		}
+	},
+	batchQuery: async (client, sqls, options) => {
+		try {
+			const results = await client.batchQuery(sqls, options);
+			if (options?.mapping) return results.map((result) => ({
+				...result,
+				rows: result.rows.map((row) => require_core.mapSQLQueryResult(row, options.mapping))
+			}));
+			return results;
+		} catch (error) {
+			require_core.tracer.error("db:sql:batch_query:execute:error", { error });
+			throw (errorMapper ?? mapSqliteError)(error);
+		}
+	},
+	command: async (client, sql, options) => {
+		require_core.tracer.info("db:sql:command", {
+			query: (formatter ?? sqliteFormatter).format(sql, { serializer }).query,
+			params: (formatter ?? sqliteFormatter).format(sql, { serializer }).params,
+			debugSQL: (formatter ?? sqliteFormatter).describe(sql, { serializer })
+		});
+		try {
+			return await client.command(sql, options);
+		} catch (error) {
+			require_core.tracer.error("db:sql:command:execute:error", { error });
+			throw (errorMapper ?? mapSqliteError)(error);
+		}
+	},
+	batchCommand: async (client, sqls, options) => {
+		try {
+			return await client.batchCommand(sqls, options);
+		} catch (error) {
+			require_core.tracer.error("db:sql:batch_command:execute:error", { error });
+			throw (errorMapper ?? mapSqliteError)(error);
+		}
+	},
+	formatter: formatter ?? sqliteFormatter
+});
+
+//#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;
+	return {
+		connection: connection(),
+		driverType,
+		begin: async function() {
+			const client = await getClient;
+			if (allowNestedTransactions) {
+				if (transactionCounter.level >= 1) {
+					transactionCounter.increment();
+					if (options?.useSavepoints) await client.command(require_core.SQL`SAVEPOINT transaction${require_core.SQL.plain(transactionCounter.level.toString())}`);
+					return;
+				}
+				transactionCounter.increment();
+			}
+			const mode = options?.mode ?? defaultTransactionMode ?? "IMMEDIATE";
+			await client.command(require_core.SQL`BEGIN ${require_core.SQL.plain(mode)} TRANSACTION`);
+		},
+		commit: async function() {
+			const client = await getClient;
+			try {
+				if (allowNestedTransactions) {
+					if (transactionCounter.level > 1) {
+						if (options?.useSavepoints) await client.command(require_core.SQL`RELEASE transaction${require_core.SQL.plain(transactionCounter.level.toString())}`);
+						transactionCounter.decrement();
+						return;
+					}
+					transactionCounter.reset();
+				}
+				await client.command(require_core.SQL`COMMIT`);
+			} finally {
+				if (options?.close) await options?.close(client);
+			}
+		},
+		rollback: async function(error) {
+			const client = await getClient;
+			try {
+				if (allowNestedTransactions) {
+					if (transactionCounter.level > 1) {
+						transactionCounter.decrement();
+						return;
+					}
+				}
+				await client.command(require_core.SQL`ROLLBACK`);
+			} finally {
+				if (options?.close) await options?.close(client, error);
+			}
+		},
+		execute: require_core.sqlExecutor(sqliteSQLExecutor(driverType, serializer), { connect: () => getClient }),
+		_transactionOptions: options ?? {}
+	};
+};
+
+//#endregion
+//#region src/storage/sqlite/core/connections/connectionString.ts
+const SQLiteConnectionString = (connectionString) => {
+	if (!connectionString.startsWith("file:") && connectionString !== ":memory:" && !connectionString.startsWith("/") && !connectionString.startsWith("./")) throw new Error(`Invalid SQLite connection string: ${connectionString}. It should start with "file:", ":memory:", "/", or "./".`);
+	return connectionString;
+};
+const parsePragmasFromConnectionString = (connectionString) => {
+	const str = String(connectionString);
+	if (!str.startsWith("file:")) return {};
+	const params = new URL(str).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);
+	const mmapSize = params.get("mmap_size");
+	if (mmapSize !== null) pragmas.mmap_size = parseInt(mmapSize, 10);
+	return pragmas;
+};
+
+//#endregion
+//#region src/storage/sqlite/core/connections/index.ts
+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 require_core.createAmbientConnection({
+		driverType,
+		client,
+		initTransaction: initTransaction ?? ((connection) => sqliteTransaction(driverType, connection, allowNestedTransactions ?? false, serializer, defaultTransactionMode)),
+		executor: ({ serializer }) => sqliteSQLExecutor(driverType, serializer, void 0, errorMapper),
+		serializer
+	});
+};
+const sqliteClientConnection = (options) => {
+	const { connectionOptions, sqliteClientFactory, serializer } = options;
+	let client = null;
+	const connect = async () => {
+		if (client) return Promise.resolve(client);
+		client = sqliteClientFactory(connectionOptions);
+		if (client && "connect" in client && typeof client.connect === "function") try {
+			await client.connect();
+		} catch (error) {
+			throw mapSqliteError(error);
+		}
+		return client;
+	};
+	return require_core.createConnection({
+		driverType: options.driverType,
+		connect,
+		close: async () => {
+			if (client && "close" in client && typeof client.close === "function") await client.close();
+			else if (client && "release" in client && typeof client.release === "function") client.release();
+		},
+		initTransaction: (connection) => sqliteTransaction(options.driverType, connection, connectionOptions.transactionOptions?.allowNestedTransactions ?? false, serializer, connectionOptions.defaultTransactionMode),
+		executor: ({ serializer }) => sqliteSQLExecutor(options.driverType, serializer),
+		serializer
+	});
+};
+const sqlitePoolClientConnection = (options) => {
+	const { connectionOptions, sqliteClientFactory, serializer } = options;
+	let client = null;
+	const connect = async () => {
+		if (client) return Promise.resolve(client);
+		client = sqliteClientFactory(connectionOptions);
+		try {
+			await client.connect();
+		} catch (error) {
+			throw mapSqliteError(error);
+		}
+		return client;
+	};
+	return require_core.createConnection({
+		driverType: options.driverType,
+		connect,
+		close: () => client !== null ? Promise.resolve(client.release()) : Promise.resolve(),
+		initTransaction: (connection) => sqliteTransaction(options.driverType, connection, connectionOptions.transactionOptions?.allowNestedTransactions ?? false, serializer, connectionOptions.defaultTransactionMode),
+		executor: ({ serializer }) => sqliteSQLExecutor(options.driverType, serializer),
+		serializer
+	});
+};
+function sqliteConnection(options) {
+	return options.type === "Client" ? sqliteClientConnection(options) : sqlitePoolClientConnection(options);
+}
+const InMemorySQLiteDatabase = SQLiteConnectionString(":memory:");
+const DEFAULT_SQLITE_PRAGMA_OPTIONS = {
+	journal_mode: "WAL",
+	synchronous: "NORMAL",
+	cache_size: -1e6,
+	foreign_keys: true,
+	temp_store: "MEMORY",
+	busy_timeout: 5e3,
+	mmap_size: 268435456
+};
+
+//#endregion
+//#region src/storage/sqlite/core/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 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 = require_core.createSingletonConnectionPool({
+		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()]);
+		}
+	};
+};
+
+//#endregion
+//#region src/storage/sqlite/core/pool/pool.ts
+const isInMemoryDatabase = (options) => {
+	if ("fileName" in options) return options.fileName === InMemorySQLiteDatabase;
+	if ("connectionString" in options) return options.connectionString === InMemorySQLiteDatabase;
+	return false;
+};
+const sqliteAmbientConnectionPool = (options) => {
+	const { connection, driverType } = options;
+	return require_core.createAmbientConnectionPool({
+		driverType,
+		connection
+	});
+};
+const sqliteSingletonConnectionPool = (options) => {
+	const { driverType, sqliteConnectionFactory, connectionOptions } = options;
+	return require_core.createSingletonConnectionPool({
+		driverType,
+		getConnection: () => sqliteConnectionFactory(connectionOptions)
+	});
+};
+const sqliteAlwaysNewConnectionPool = (options) => {
+	const { driverType, sqliteConnectionFactory, connectionOptions } = options;
+	return require_core.createAlwaysNewConnectionPool({
+		driverType,
+		getConnection: () => sqliteConnectionFactory(connectionOptions)
+	});
+};
+const toSqlitePoolOptions = (options) => {
+	const { singleton, ...rest } = options;
+	const isInMemory = isInMemoryDatabase(options);
+	if ("client" in options && options.client) return {
+		...rest,
+		singleton: true
+	};
+	if (isInMemory) return {
+		...rest,
+		singleton: true
+	};
+	if (singleton === true) return {
+		...rest,
+		singleton: true
+	};
+	return {
+		...rest,
+		dual: true
+	};
+};
+function sqlitePool(options) {
+	const { driverType } = options;
+	if (options.connection) return require_core.createAmbientConnectionPool({
+		driverType,
+		connection: options.connection
+	});
+	if ("dual" in options && options.dual) return sqliteDualConnectionPool(options);
+	if (options.singleton === true && options.sqliteConnectionFactory) return require_core.createSingletonConnectionPool({
+		driverType,
+		getConnection: () => options.sqliteConnectionFactory(options.connectionOptions)
+	});
+	return require_core.createAlwaysNewConnectionPool({
+		driverType,
+		getConnection: () => options.sqliteConnectionFactory(options.connectionOptions)
+	});
+}
+
+//#endregion
+//#region src/storage/sqlite/core/schema/migrations.ts
+const DefaultSQLiteMigratorOptions = {};
+require_core.registerDefaultMigratorOptions("SQLite", DefaultSQLiteMigratorOptions);
+
+//#endregion
+//#region src/storage/sqlite/core/index.ts
+const SQLiteDatabaseName = "SQLite";
+
+//#endregion
+Object.defineProperty(exports, 'DEFAULT_SQLITE_PRAGMA_OPTIONS', {
+  enumerable: true,
+  get: function () {
+    return DEFAULT_SQLITE_PRAGMA_OPTIONS;
+  }
+});
+Object.defineProperty(exports, 'DefaultSQLiteMigratorOptions', {
+  enumerable: true,
+  get: function () {
+    return DefaultSQLiteMigratorOptions;
+  }
+});
+Object.defineProperty(exports, 'InMemorySQLiteDatabase', {
+  enumerable: true,
+  get: function () {
+    return InMemorySQLiteDatabase;
+  }
+});
+Object.defineProperty(exports, 'SQLiteConnectionString', {
+  enumerable: true,
+  get: function () {
+    return SQLiteConnectionString;
+  }
+});
+Object.defineProperty(exports, 'SQLiteDatabaseName', {
+  enumerable: true,
+  get: function () {
+    return SQLiteDatabaseName;
+  }
+});
+Object.defineProperty(exports, 'isInMemoryDatabase', {
+  enumerable: true,
+  get: function () {
+    return isInMemoryDatabase;
+  }
+});
+Object.defineProperty(exports, 'isSQLiteError', {
+  enumerable: true,
+  get: function () {
+    return isSQLiteError;
+  }
+});
+Object.defineProperty(exports, 'mapSqliteError', {
+  enumerable: true,
+  get: function () {
+    return mapSqliteError;
+  }
+});
+Object.defineProperty(exports, 'parsePragmasFromConnectionString', {
+  enumerable: true,
+  get: function () {
+    return parsePragmasFromConnectionString;
+  }
+});
+Object.defineProperty(exports, 'sqliteAlwaysNewConnectionPool', {
+  enumerable: true,
+  get: function () {
+    return sqliteAlwaysNewConnectionPool;
+  }
+});
+Object.defineProperty(exports, 'sqliteAmbientClientConnection', {
+  enumerable: true,
+  get: function () {
+    return sqliteAmbientClientConnection;
+  }
+});
+Object.defineProperty(exports, 'sqliteAmbientConnectionPool', {
+  enumerable: true,
+  get: function () {
+    return sqliteAmbientConnectionPool;
+  }
+});
+Object.defineProperty(exports, 'sqliteClientConnection', {
+  enumerable: true,
+  get: function () {
+    return sqliteClientConnection;
+  }
+});
+Object.defineProperty(exports, 'sqliteConnection', {
+  enumerable: true,
+  get: function () {
+    return sqliteConnection;
+  }
+});
+Object.defineProperty(exports, 'sqliteExecute', {
+  enumerable: true,
+  get: function () {
+    return sqliteExecute;
+  }
+});
+Object.defineProperty(exports, 'sqliteFormatter', {
+  enumerable: true,
+  get: function () {
+    return sqliteFormatter;
+  }
+});
+Object.defineProperty(exports, 'sqlitePool', {
+  enumerable: true,
+  get: function () {
+    return sqlitePool;
+  }
+});
+Object.defineProperty(exports, 'sqlitePoolClientConnection', {
+  enumerable: true,
+  get: function () {
+    return sqlitePoolClientConnection;
+  }
+});
+Object.defineProperty(exports, 'sqliteSQLExecutor', {
+  enumerable: true,
+  get: function () {
+    return sqliteSQLExecutor;
+  }
+});
+Object.defineProperty(exports, 'sqliteSingletonConnectionPool', {
+  enumerable: true,
+  get: function () {
+    return sqliteSingletonConnectionPool;
+  }
+});
+Object.defineProperty(exports, 'sqliteTransaction', {
+  enumerable: true,
+  get: function () {
+    return sqliteTransaction;
+  }
+});
+Object.defineProperty(exports, 'toSqlitePoolOptions', {
+  enumerable: true,
+  get: function () {
+    return toSqlitePoolOptions;
+  }
+});
+Object.defineProperty(exports, 'transactionNestingCounter', {
+  enumerable: true,
+  get: function () {
+    return transactionNestingCounter;
+  }
+});
+//# sourceMappingURL=core-DmbB4qMn.cjs.map