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

package/dist/sqlite3.js

@@ -1,282 +1,412 @@
-import {
-  DefaultSQLiteMigratorOptions,
-  InMemorySQLiteDatabase,
-  SQLiteConnectionString,
-  SQLiteDatabaseName,
-  defaultPostgreSqlDatabase,
-  isInMemoryDatabase,
-  isSQLiteError,
-  sqliteAlwaysNewConnectionPool,
-  sqliteAmbientClientConnection,
-  sqliteAmbientConnectionPool,
-  sqliteClientConnection,
-  sqliteConnection,
-  sqliteExecute,
-  sqliteFormatter,
-  sqlitePool,
-  sqlitePoolClientConnection,
-  sqliteSQLExecutor,
-  sqliteSingletonConnectionPool,
-  sqliteTransaction,
-  tableExists,
-  tableExistsSQL,
-  toSqlitePoolOptions,
-  transactionNestingCounter
-} from "./chunk-XVV3OOQX.js";
-import "./chunk-6IHCIJ7S.js";
-import {
-  SQL,
-  canHandleDriverWithConnectionString,
-  dumboDatabaseDriverRegistry
-} from "./chunk-N7RWT46K.js";
-
-// src/storage/sqlite/sqlite3/connections/connection.ts
+import { On as canHandleDriverWithConnectionString, c as TaskProcessor, in as JSONSerializer, kn as dumboDatabaseDriverRegistry, o as createSingletonConnectionPool, r as createBoundedConnectionPool, s as guardInitializedOnce, v as BatchCommandNoChangesError, xt as SQL } from "./core-BMeDuqBQ.js";
+import { n as defaultSQLiteDatabase, r as tableExists, t as sqliteMetadata } from "./sqliteMetadata-viYmVwA5.js";
+import { C as mapSqliteError, S as sqliteFormatter, _ as SQLiteConnectionString, a as sqliteAmbientConnectionPool, b as sqliteExecute, c as toSqlitePoolOptions, d as isSQLiteError, f as sqliteAmbientClientConnection, g as transactionNestingCounter, h as sqlitePoolClientConnection, i as sqliteAlwaysNewConnectionPool, l as DEFAULT_SQLITE_PRAGMA_OPTIONS, m as sqliteConnection, n as DefaultSQLiteMigratorOptions, o as sqlitePool, p as sqliteClientConnection, r as isInMemoryDatabase, s as sqliteSingletonConnectionPool, t as SQLiteDatabaseName, u as InMemorySQLiteDatabase, v as parsePragmasFromConnectionString, x as sqliteSQLExecutor, y as sqliteTransaction } from "./core-gu5fi784.js";
 import sqlite3 from "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 sqlite3.Database(
-        options.fileName ?? options.connectionString ?? InMemorySQLiteDatabase,
-        sqlite3.OPEN_URI | sqlite3.OPEN_READWRITE | sqlite3.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, 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 (options2?.ignoreChangesCount === true) {
-        db.run(
-          sql,
-          params ?? [],
-          function(err, rows) {
-            if (err) {
-              reject(err);
-              return;
-            }
-            resolve({
-              rowCount: 0,
-              rows: rows ?? []
-            });
-          }
-        );
-      }
-      db.serialize(() => {
-        db.all(sql, params ?? [], (err, rows) => {
-          if (err) {
-            reject(err);
-            return;
-          }
-          db.get(
-            "SELECT changes() as changes",
-            (changesErr, row) => {
-              if (changesErr) {
-                reject(changesErr);
-                return;
-              }
-              resolve({
-                rowCount: row?.changes ?? 0,
-                rows: 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 } = 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 } = 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 } = sqliteFormatter.format(sql);
-      return executeCommand(
-        query,
-        params,
-        options2
-      );
-    },
-    batchCommand: async (sqls, options2) => {
-      const results = [];
-      for (const sql of sqls) {
-        const { query, params } = sqliteFormatter.format(sql);
-        const result = await executeCommand(
-          query,
-          params,
-          options2
-        );
-        results.push(result);
-      }
-      return results;
-    }
-  };
+import { cpus } from "os";
+import { AsyncLocalStorage } from "node:async_hooks";
+
+//#region src/storage/sqlite/core/connections/pragmas.ts
+const mergePragmaOptions = (connectionString, userOptions) => {
+	const connectionStringPragmas = parsePragmasFromConnectionString(connectionString);
+	return {
+		...DEFAULT_SQLITE_PRAGMA_OPTIONS,
+		...connectionStringPragmas,
+		...userOptions
+	};
+};
+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();
+		});
+	});
+};
+const queryPragma = (database, pragma) => new Promise((resolve, reject) => {
+	database.get(`PRAGMA ${pragma};`, (err, row) => {
+		if (err) reject(err);
+		else resolve(row?.[pragma] ?? "");
+	});
+});
+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 ?? 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.Database(connectionString, sqlite3.OPEN_URI | sqlite3.OPEN_READWRITE | sqlite3.OPEN_CREATE, (err) => {
+				if (err) {
+					reject(err);
+					return;
+				}
+				const busyTimeout = finalPragmas.busy_timeout ?? 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 mapSqliteError(error);
+			}
+		},
+		query: async (sql, _options) => {
+			try {
+				const { query, params } = sqliteFormatter.format(sql, { serializer });
+				const result = await executeQuery(query, params);
+				return {
+					rowCount: result.length,
+					rows: result
+				};
+			} catch (error) {
+				throw mapSqliteError(error);
+			}
+		},
+		batchQuery: async (sqls, _options) => {
+			try {
+				const results = [];
+				for (const sql of sqls) {
+					const { query, params } = sqliteFormatter.format(sql, { serializer });
+					const result = await executeQuery(query, params);
+					results.push({
+						rowCount: result.length,
+						rows: result
+					});
+				}
+				return results;
+			} catch (error) {
+				throw mapSqliteError(error);
+			}
+		},
+		command: async (sql, options) => {
+			try {
+				const { query, params } = sqliteFormatter.format(sql, { serializer });
+				return await executeCommand(query, params, options);
+			} catch (error) {
+				throw mapSqliteError(error);
+			}
+		},
+		batchCommand: async (sqls, options) => {
+			try {
+				const results = [];
+				for (let i = 0; i < sqls.length; i++) {
+					const { query, params } = sqliteFormatter.format(sqls[i], { serializer });
+					const result = await executeCommand(query, params, options);
+					results.push(result);
+					if (options?.assertChanges && (result.rowCount ?? 0) === 0) throw new BatchCommandNoChangesError(i);
+				}
+				return results;
+			} catch (error) {
+				throw mapSqliteError(error);
+			}
+		}
+	};
 };
-var checkConnection = async (fileName) => {
-  const client = sqlite3Client({
-    fileName
-  });
-  try {
-    await client.query(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(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) => sqliteConnection({
-  type: "Client",
-  driverType: SQLite3DriverType,
-  sqliteClientFactory: (connectionOptions) => {
-    if ("client" in connectionOptions && connectionOptions.client) {
-      return connectionOptions.client;
-    }
-    return sqlite3Client(connectionOptions);
-  },
-  connectionOptions: options
+const sqlite3Connection = (options) => 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) => sqlitePool(
-  toSqlitePoolOptions({
-    ...options,
-    driverType: SQLite3DriverType,
-    ..."connection" in options ? {} : {
-      connectionOptions: options,
-      sqliteConnectionFactory: (opts) => sqlite3Connection(opts)
-    }
-  })
-);
-var tryParseConnectionString = (connectionString) => {
-  try {
-    return SQLiteConnectionString(connectionString);
-  } catch {
-    return null;
-  }
+//#endregion
+//#region src/storage/sqlite/sqlite3/pool/singletonPool.ts
+const sqlite3SingletonPool = (options) => {
+	const inner = createSingletonConnectionPool({
+		driverType: options.driverType,
+		getConnection: options.getConnection,
+		...options.closeConnection ? { closeConnection: options.closeConnection } : {}
+	});
+	const taskProcessor = new TaskProcessor({
+		maxActiveTasks: 1,
+		maxQueueSize: options.maxQueueSize ?? 1e3
+	});
+	const insideWriterTask = new 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 sqlite3DatabaseDriver = {
-  driverType: SQLite3DriverType,
-  createPool: (options) => sqlite3Pool(options),
-  sqlFormatter: sqliteFormatter,
-  defaultMigratorOptions: DefaultSQLiteMigratorOptions,
-  getDatabaseNameOrDefault: () => InMemorySQLiteDatabase,
-  canHandle: canHandleDriverWithConnectionString(
-    SQLite3DriverType,
-    tryParseConnectionString
-  )
+
+//#endregion
+//#region src/storage/sqlite/sqlite3/pool/dualPool.ts
+const sqliteDualConnectionPool = (options) => {
+	const { sqliteConnectionFactory, connectionOptions } = options;
+	const readerPoolSize = options.readerPoolSize ?? Math.max(4, cpus().length);
+	let databaseInitPromise = null;
+	const guardSingleConnection = 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 = sqlite3SingletonPool({
+		driverType: options.driverType,
+		getConnection: () => wrappedConnectionFactory(false, connectionOptions)
+	});
+	const readerPool = 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/sqlite3/index.ts
+const sqlite3Pool = (options) => {
+	if ("connection" in options && options.connection) return sqlitePool(toSqlitePoolOptions({
+		...options,
+		driverType: SQLite3DriverType
+	}));
+	const sqliteConnectionFactory = (opts) => sqlite3Connection({
+		...opts,
+		serializer: options.serializer ?? JSONSerializer
+	});
+	if (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 } : {}
+	});
 };
-var useSqlite3DatabaseDriver = () => {
-  dumboDatabaseDriverRegistry.register(
-    SQLite3DriverType,
-    sqlite3DatabaseDriver
-  );
+const tryParseConnectionString = (connectionString) => {
+	try {
+		return SQLiteConnectionString(connectionString);
+	} catch {
+		return null;
+	}
 };
-useSqlite3DatabaseDriver();
-export {
-  DefaultSQLiteMigratorOptions,
-  InMemorySQLiteDatabase,
-  SQLite3DriverType,
-  SQLiteConnectionString,
-  SQLiteDatabaseName,
-  checkConnection,
-  sqlite3Pool as connectionPool,
-  sqlite3DatabaseDriver as databaseDriver,
-  defaultPostgreSqlDatabase,
-  isInMemoryDatabase,
-  isSQLiteError,
-  sqlite3Client,
-  sqlite3Connection,
-  sqlite3DatabaseDriver,
-  sqlite3Pool,
-  sqliteAlwaysNewConnectionPool,
-  sqliteAmbientClientConnection,
-  sqliteAmbientConnectionPool,
-  sqlite3Client as sqliteClient,
-  sqliteClientConnection,
-  sqliteConnection,
-  sqliteExecute,
-  sqliteFormatter,
-  sqlitePool,
-  sqlitePoolClientConnection,
-  sqliteSQLExecutor,
-  sqliteSingletonConnectionPool,
-  sqliteTransaction,
-  tableExists,
-  tableExistsSQL,
-  toSqlitePoolOptions,
-  transactionNestingCounter,
-  useSqlite3DatabaseDriver
+const sqlite3DumboDriver = {
+	driverType: SQLite3DriverType,
+	createPool: (options) => sqlite3Pool(options),
+	sqlFormatter: sqliteFormatter,
+	defaultMigratorOptions: DefaultSQLiteMigratorOptions,
+	canHandle: canHandleDriverWithConnectionString(SQLite3DriverType, tryParseConnectionString),
+	databaseMetadata: sqliteMetadata
 };
+const useSqlite3DumboDriver = () => {
+	dumboDatabaseDriverRegistry.register(SQLite3DriverType, sqlite3DumboDriver);
+};
+useSqlite3DumboDriver();
+
+//#endregion
+export { DEFAULT_SQLITE_PRAGMA_OPTIONS, DefaultSQLiteMigratorOptions, InMemorySQLiteDatabase, SQLite3DriverType, SQLiteConnectionString, SQLiteDatabaseName, checkConnection, defaultSQLiteDatabase, isInMemoryDatabase, isSQLiteError, mapSqliteError, parsePragmasFromConnectionString, sqlite3Client, sqlite3Connection, sqlite3DumboDriver, sqlite3Pool, sqliteAlwaysNewConnectionPool, sqliteAmbientClientConnection, sqliteAmbientConnectionPool, sqliteClientConnection, sqliteConnection, sqliteExecute, sqliteFormatter, sqliteMetadata, sqlitePool, sqlitePoolClientConnection, sqliteSQLExecutor, sqliteSingletonConnectionPool, sqliteTransaction, tableExists, toSqlitePoolOptions, transactionNestingCounter, useSqlite3DumboDriver };
 //# sourceMappingURL=sqlite3.js.map