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

package/dist/chunk-JIZGCEPE.cjs

@@ -1,701 +0,0 @@
-"use strict";Object.defineProperty(exports, "__esModule", {value: true}); 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 _chunk4MMMEDQ7cjs = require('./chunk-4MMMEDQ7.cjs');
-
-// src/storage/sqlite/core/errors/errorMapper.ts
-var getSqliteErrorCode = (error) => {
-  if (error instanceof Error && "code" in error && typeof error.code === "string") {
-    return error.code;
-  }
-  return void 0;
-};
-var getErrorMessage = (error) => error instanceof Error ? error.message : void 0;
-var asError = (error) => error instanceof Error ? error : void 0;
-var mapConstraintError = (message, innerError) => {
-  const upperMessage = _nullishCoalesce(_optionalChain([message, 'optionalAccess', _ => _.toUpperCase, 'call', _2 => _2()]), () => ( ""));
-  if (upperMessage.includes("UNIQUE") || upperMessage.includes("PRIMARY KEY"))
-    return new (0, _chunk4MMMEDQ7cjs.UniqueConstraintError)(message, innerError);
-  if (upperMessage.includes("FOREIGN KEY"))
-    return new (0, _chunk4MMMEDQ7cjs.ForeignKeyViolationError)(message, innerError);
-  if (upperMessage.includes("NOT NULL"))
-    return new (0, _chunk4MMMEDQ7cjs.NotNullViolationError)(message, innerError);
-  if (upperMessage.includes("CHECK"))
-    return new (0, _chunk4MMMEDQ7cjs.CheckViolationError)(message, innerError);
-  return new (0, _chunk4MMMEDQ7cjs.IntegrityConstraintViolationError)(message, innerError);
-};
-var mapSqliteError = (error) => {
-  if (_chunk4MMMEDQ7cjs.DumboError.isInstanceOf(error)) return error;
-  const code = getSqliteErrorCode(error);
-  if (!code)
-    return new (0, _chunk4MMMEDQ7cjs.DumboError)({
-      errorCode: 500,
-      message: getErrorMessage(error),
-      innerError: asError(error)
-    });
-  const message = getErrorMessage(error);
-  const innerError = asError(error);
-  switch (code) {
-    // ── Constraint violations (19) ──
-    // node-sqlite3 only exposes the primary code; subtype is in the message.
-    case "SQLITE_CONSTRAINT":
-      return mapConstraintError(message, innerError);
-    // ── Busy / lock contention ──
-    // SQLITE_BUSY (5): conflict with a separate database connection
-    case "SQLITE_BUSY":
-      return new (0, _chunk4MMMEDQ7cjs.LockNotAvailableError)(message, innerError);
-    // SQLITE_LOCKED (6): conflict within the same connection or shared cache
-    case "SQLITE_LOCKED":
-      return new (0, _chunk4MMMEDQ7cjs.DeadlockError)(message, innerError);
-    // SQLITE_PROTOCOL (15): WAL locking race condition
-    case "SQLITE_PROTOCOL":
-      return new (0, _chunk4MMMEDQ7cjs.LockNotAvailableError)(message, innerError);
-    // ── Connection / open errors ──
-    // SQLITE_CANTOPEN (14): unable to open database file
-    case "SQLITE_CANTOPEN":
-      return new (0, _chunk4MMMEDQ7cjs.ConnectionError)(message, innerError);
-    // SQLITE_NOTADB (26): file is not a database
-    case "SQLITE_NOTADB":
-      return new (0, _chunk4MMMEDQ7cjs.ConnectionError)(message, innerError);
-    // ── Resource exhaustion ──
-    // SQLITE_NOMEM (7): out of memory
-    case "SQLITE_NOMEM":
-      return new (0, _chunk4MMMEDQ7cjs.InsufficientResourcesError)(message, innerError);
-    // SQLITE_FULL (13): disk full
-    case "SQLITE_FULL":
-      return new (0, _chunk4MMMEDQ7cjs.InsufficientResourcesError)(message, innerError);
-    // ── System / I/O errors ──
-    // SQLITE_IOERR (10): operating system I/O error
-    case "SQLITE_IOERR":
-      return new (0, _chunk4MMMEDQ7cjs.SystemError)(message, innerError);
-    // SQLITE_CORRUPT (11): database file is corrupted
-    case "SQLITE_CORRUPT":
-      return new (0, _chunk4MMMEDQ7cjs.SystemError)(message, innerError);
-    // SQLITE_INTERNAL (2): internal SQLite malfunction
-    case "SQLITE_INTERNAL":
-      return new (0, _chunk4MMMEDQ7cjs.SystemError)(message, innerError);
-    // SQLITE_NOLFS (22): large file support unavailable
-    case "SQLITE_NOLFS":
-      return new (0, _chunk4MMMEDQ7cjs.SystemError)(message, innerError);
-    // ── Data errors ──
-    // SQLITE_TOOBIG (18): string or BLOB too large
-    case "SQLITE_TOOBIG":
-      return new (0, _chunk4MMMEDQ7cjs.DataError)(message, innerError);
-    // SQLITE_MISMATCH (20): datatype mismatch
-    case "SQLITE_MISMATCH":
-      return new (0, _chunk4MMMEDQ7cjs.DataError)(message, innerError);
-    // SQLITE_RANGE (25): bind parameter index out of range
-    case "SQLITE_RANGE":
-      return new (0, _chunk4MMMEDQ7cjs.DataError)(message, innerError);
-    // ── Invalid operations ──
-    // SQLITE_ERROR (1): generic SQL error (syntax errors, missing tables, etc.)
-    case "SQLITE_ERROR":
-      return new (0, _chunk4MMMEDQ7cjs.InvalidOperationError)(message, innerError);
-    // SQLITE_READONLY (8): attempt to write to a read-only database
-    case "SQLITE_READONLY":
-      return new (0, _chunk4MMMEDQ7cjs.InvalidOperationError)(message, innerError);
-    // SQLITE_MISUSE (21): API misuse
-    case "SQLITE_MISUSE":
-      return new (0, _chunk4MMMEDQ7cjs.InvalidOperationError)(message, innerError);
-    // SQLITE_AUTH (23): authorization denied
-    case "SQLITE_AUTH":
-      return new (0, _chunk4MMMEDQ7cjs.InvalidOperationError)(message, innerError);
-    // SQLITE_PERM (3): access permission denied
-    case "SQLITE_PERM":
-      return new (0, _chunk4MMMEDQ7cjs.InvalidOperationError)(message, innerError);
-    // SQLITE_SCHEMA (17): schema changed, statement needs re-preparation
-    case "SQLITE_SCHEMA":
-      return new (0, _chunk4MMMEDQ7cjs.InvalidOperationError)(message, innerError);
-    // ── Transaction / abort ──
-    // SQLITE_ABORT (4): operation aborted (e.g. by rollback)
-    case "SQLITE_ABORT":
-      return new (0, _chunk4MMMEDQ7cjs.SerializationError)(message, innerError);
-    // SQLITE_INTERRUPT (9): operation interrupted
-    case "SQLITE_INTERRUPT":
-      return new (0, _chunk4MMMEDQ7cjs.SerializationError)(message, innerError);
-  }
-  return new (0, _chunk4MMMEDQ7cjs.DumboError)({
-    errorCode: 500,
-    message,
-    innerError
-  });
-};
-
-// src/storage/sqlite/core/sql/processors/columProcessors.ts
-var 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: {
-      const exhaustiveCheck = sqlTokenType;
-      throw new Error(`Unknown column type: ${exhaustiveCheck}`);
-    }
-  }
-  builder.addSQL(columnSQL);
-};
-var sqliteColumnProcessors = _chunk4MMMEDQ7cjs.mapDefaultSQLColumnProcessors.call(void 0, mapColumnType);
-
-// src/storage/sqlite/core/sql/formatter/index.ts
-var sqliteSQLProcessorsRegistry = _chunk4MMMEDQ7cjs.SQLProcessorsRegistry.call(void 0, {
-  from: _chunk4MMMEDQ7cjs.defaultProcessorsRegistry
-}).register(sqliteColumnProcessors);
-var sqliteFormatter = _chunk4MMMEDQ7cjs.SQLFormatter.call(void 0, {
-  processorsRegistry: sqliteSQLProcessorsRegistry
-});
-_chunk4MMMEDQ7cjs.registerFormatter.call(void 0, "SQLite", sqliteFormatter);
-
-// src/storage/sqlite/core/execute/execute.ts
-var sqliteExecute = async (database, handle) => {
-  try {
-    return await handle(database);
-  } finally {
-    await database.close();
-  }
-};
-var sqliteSQLExecutor = (driverType, serializer, formatter, errorMapper) => ({
-  driverType,
-  query: async (client, sql, options) => {
-    _chunk4MMMEDQ7cjs.tracer.info("db:sql:query", {
-      query: (_nullishCoalesce(formatter, () => ( sqliteFormatter))).format(sql, { serializer }).query,
-      params: (_nullishCoalesce(formatter, () => ( sqliteFormatter))).format(sql, { serializer }).params,
-      debugSQL: (_nullishCoalesce(formatter, () => ( sqliteFormatter))).describe(sql, { serializer })
-    });
-    try {
-      let result = await client.query(sql, options);
-      if (_optionalChain([options, 'optionalAccess', _3 => _3.mapping])) {
-        result = {
-          ...result,
-          rows: result.rows.map(
-            (row) => _chunk4MMMEDQ7cjs.mapSQLQueryResult.call(void 0, row, options.mapping)
-          )
-        };
-      }
-      return result;
-    } catch (error) {
-      _chunk4MMMEDQ7cjs.tracer.error("db:sql:query:execute:error", { error });
-      throw (_nullishCoalesce(errorMapper, () => ( mapSqliteError)))(error);
-    }
-  },
-  batchQuery: async (client, sqls, options) => {
-    try {
-      const results = await client.batchQuery(sqls, options);
-      if (_optionalChain([options, 'optionalAccess', _4 => _4.mapping])) {
-        return results.map((result) => ({
-          ...result,
-          rows: result.rows.map(
-            (row) => _chunk4MMMEDQ7cjs.mapSQLQueryResult.call(void 0, row, options.mapping)
-          )
-        }));
-      }
-      return results;
-    } catch (error) {
-      _chunk4MMMEDQ7cjs.tracer.error("db:sql:batch_query:execute:error", { error });
-      throw (_nullishCoalesce(errorMapper, () => ( mapSqliteError)))(error);
-    }
-  },
-  command: async (client, sql, options) => {
-    _chunk4MMMEDQ7cjs.tracer.info("db:sql:command", {
-      query: (_nullishCoalesce(formatter, () => ( sqliteFormatter))).format(sql, { serializer }).query,
-      params: (_nullishCoalesce(formatter, () => ( sqliteFormatter))).format(sql, { serializer }).params,
-      debugSQL: (_nullishCoalesce(formatter, () => ( sqliteFormatter))).describe(sql, { serializer })
-    });
-    try {
-      return await client.command(sql, options);
-    } catch (error) {
-      _chunk4MMMEDQ7cjs.tracer.error("db:sql:command:execute:error", { error });
-      throw (_nullishCoalesce(errorMapper, () => ( mapSqliteError)))(error);
-    }
-  },
-  batchCommand: async (client, sqls, options) => {
-    try {
-      return await client.batchCommand(sqls, options);
-    } catch (error) {
-      _chunk4MMMEDQ7cjs.tracer.error("db:sql:batch_command:execute:error", { error });
-      throw (_nullishCoalesce(errorMapper, () => ( mapSqliteError)))(error);
-    }
-  },
-  formatter: _nullishCoalesce(formatter, () => ( sqliteFormatter))
-});
-
-// src/storage/sqlite/core/connections/connectionString.ts
-var 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;
-};
-var parsePragmasFromConnectionString = (connectionString) => {
-  const str = String(connectionString);
-  if (!str.startsWith("file:")) {
-    return {};
-  }
-  const url = new URL(str);
-  const params = url.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;
-};
-
-// src/storage/sqlite/core/connections/index.ts
-var isSQLiteError = (error) => {
-  if (error instanceof Error && "code" in error) {
-    return true;
-  }
-  return false;
-};
-var 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;
-    }
-  };
-};
-var sqliteAmbientClientConnection = (options) => {
-  const {
-    client,
-    driverType,
-    initTransaction,
-    allowNestedTransactions,
-    defaultTransactionMode,
-    serializer,
-    errorMapper
-  } = options;
-  return _chunk4MMMEDQ7cjs.createAmbientConnection.call(void 0, {
-    driverType,
-    client,
-    initTransaction: _nullishCoalesce(initTransaction, () => ( ((connection) => sqliteTransaction(
-      driverType,
-      connection,
-      _nullishCoalesce(allowNestedTransactions, () => ( false)),
-      serializer,
-      defaultTransactionMode
-    )))),
-    executor: ({ serializer: serializer2 }) => sqliteSQLExecutor(driverType, serializer2, void 0, errorMapper),
-    serializer
-  });
-};
-var 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 _chunk4MMMEDQ7cjs.createConnection.call(void 0, {
-    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,
-      _nullishCoalesce(_optionalChain([connectionOptions, 'access', _5 => _5.transactionOptions, 'optionalAccess', _6 => _6.allowNestedTransactions]), () => ( false)),
-      serializer,
-      connectionOptions.defaultTransactionMode
-    ),
-    executor: ({ serializer: serializer2 }) => sqliteSQLExecutor(options.driverType, serializer2),
-    serializer
-  });
-};
-var 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 _chunk4MMMEDQ7cjs.createConnection.call(void 0, {
-    driverType: options.driverType,
-    connect,
-    close: () => client !== null ? Promise.resolve(client.release()) : Promise.resolve(),
-    initTransaction: (connection) => sqliteTransaction(
-      options.driverType,
-      connection,
-      _nullishCoalesce(_optionalChain([connectionOptions, 'access', _7 => _7.transactionOptions, 'optionalAccess', _8 => _8.allowNestedTransactions]), () => ( false)),
-      serializer,
-      connectionOptions.defaultTransactionMode
-    ),
-    executor: ({ serializer: serializer2 }) => sqliteSQLExecutor(options.driverType, serializer2),
-    serializer
-  });
-};
-function sqliteConnection(options) {
-  return options.type === "Client" ? sqliteClientConnection(options) : sqlitePoolClientConnection(options);
-}
-var InMemorySQLiteDatabase = SQLiteConnectionString(":memory:");
-var DEFAULT_SQLITE_PRAGMA_OPTIONS = {
-  journal_mode: "WAL",
-  synchronous: "NORMAL",
-  cache_size: -1e6,
-  foreign_keys: true,
-  temp_store: "MEMORY",
-  busy_timeout: 5e3,
-  mmap_size: 268435456
-};
-
-// src/storage/sqlite/core/transactions/index.ts
-var sqliteTransaction = (driverType, connection, allowNestedTransactions, serializer, defaultTransactionMode) => (getClient, options) => {
-  const transactionCounter = transactionNestingCounter();
-  allowNestedTransactions = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _9 => _9.allowNestedTransactions]), () => ( allowNestedTransactions));
-  const transaction = {
-    connection: connection(),
-    driverType,
-    begin: async function() {
-      const client = await getClient;
-      if (allowNestedTransactions) {
-        if (transactionCounter.level >= 1) {
-          transactionCounter.increment();
-          if (_optionalChain([options, 'optionalAccess', _10 => _10.useSavepoints])) {
-            await client.command(
-              _chunk4MMMEDQ7cjs.SQL`SAVEPOINT transaction${_chunk4MMMEDQ7cjs.SQL.plain(transactionCounter.level.toString())}`
-            );
-          }
-          return;
-        }
-        transactionCounter.increment();
-      }
-      const mode = _nullishCoalesce(_nullishCoalesce(_optionalChain([options, 'optionalAccess', _11 => _11.mode]), () => ( defaultTransactionMode)), () => ( "IMMEDIATE"));
-      await client.command(_chunk4MMMEDQ7cjs.SQL`BEGIN ${_chunk4MMMEDQ7cjs.SQL.plain(mode)} TRANSACTION`);
-    },
-    commit: async function() {
-      const client = await getClient;
-      try {
-        if (allowNestedTransactions) {
-          if (transactionCounter.level > 1) {
-            if (_optionalChain([options, 'optionalAccess', _12 => _12.useSavepoints])) {
-              await client.command(
-                _chunk4MMMEDQ7cjs.SQL`RELEASE transaction${_chunk4MMMEDQ7cjs.SQL.plain(transactionCounter.level.toString())}`
-              );
-            }
-            transactionCounter.decrement();
-            return;
-          }
-          transactionCounter.reset();
-        }
-        await client.command(_chunk4MMMEDQ7cjs.SQL`COMMIT`);
-      } finally {
-        if (_optionalChain([options, 'optionalAccess', _13 => _13.close]))
-          await _optionalChain([options, 'optionalAccess', _14 => _14.close, 'call', _15 => _15(
-            client
-          )]);
-      }
-    },
-    rollback: async function(error) {
-      const client = await getClient;
-      try {
-        if (allowNestedTransactions) {
-          if (transactionCounter.level > 1) {
-            transactionCounter.decrement();
-            return;
-          }
-        }
-        await client.command(_chunk4MMMEDQ7cjs.SQL`ROLLBACK`);
-      } finally {
-        if (_optionalChain([options, 'optionalAccess', _16 => _16.close]))
-          await _optionalChain([options, 'optionalAccess', _17 => _17.close, 'call', _18 => _18(
-            client,
-            error
-          )]);
-      }
-    },
-    execute: _chunk4MMMEDQ7cjs.sqlExecutor.call(void 0, sqliteSQLExecutor(driverType, serializer), {
-      connect: () => getClient
-    }),
-    _transactionOptions: _nullishCoalesce(options, () => ( {}))
-  };
-  return transaction;
-};
-
-// src/storage/sqlite/core/pool/dualPool.ts
-var _os = require('os');
-var sqliteDualConnectionPool = (options) => {
-  const { sqliteConnectionFactory, connectionOptions } = options;
-  const readerPoolSize = _nullishCoalesce(options.readerPoolSize, () => ( Math.max(4, _os.cpus.call(void 0, ).length)));
-  let databaseInitPromise = null;
-  const guardSingleConnection = _chunk4MMMEDQ7cjs.guardInitializedOnce.call(void 0, 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, connectionOptions2) => {
-    await ensureDatabaseInitialized();
-    const connection = sqliteConnectionFactory({
-      ...connectionOptions2,
-      skipDatabasePragmas: true,
-      readonly
-    });
-    await connection.open();
-    return connection;
-  };
-  const writerPool = _chunk4MMMEDQ7cjs.createSingletonConnectionPool.call(void 0, {
-    driverType: options.driverType,
-    getConnection: () => wrappedConnectionFactory(false, connectionOptions)
-  });
-  const readerPool = _chunk4MMMEDQ7cjs.createBoundedConnectionPool.call(void 0, {
-    driverType: options.driverType,
-    getConnection: () => wrappedConnectionFactory(true, connectionOptions),
-    maxConnections: readerPoolSize
-  });
-  return {
-    driverType: options.driverType,
-    connection: (connectionOptions2) => _optionalChain([connectionOptions2, 'optionalAccess', _19 => _19.readonly]) ? readerPool.connection(connectionOptions2) : writerPool.connection(connectionOptions2),
-    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, connectionOptions2) => _optionalChain([connectionOptions2, 'optionalAccess', _20 => _20.readonly]) ? readerPool.withConnection(handle, connectionOptions2) : writerPool.withConnection(handle, connectionOptions2),
-    transaction: writerPool.transaction,
-    withTransaction: writerPool.withTransaction,
-    close: async () => {
-      await guardSingleConnection.stop();
-      await Promise.all([writerPool.close(), readerPool.close()]);
-    }
-  };
-};
-
-// src/storage/sqlite/core/pool/pool.ts
-var isInMemoryDatabase = (options) => {
-  if ("fileName" in options) {
-    return options.fileName === InMemorySQLiteDatabase;
-  }
-  if ("connectionString" in options) {
-    return options.connectionString === InMemorySQLiteDatabase;
-  }
-  return false;
-};
-var sqliteAmbientConnectionPool = (options) => {
-  const { connection, driverType } = options;
-  return _chunk4MMMEDQ7cjs.createAmbientConnectionPool.call(void 0, {
-    driverType,
-    connection
-  });
-};
-var sqliteSingletonConnectionPool = (options) => {
-  const { driverType, sqliteConnectionFactory, connectionOptions } = options;
-  return _chunk4MMMEDQ7cjs.createSingletonConnectionPool.call(void 0, {
-    driverType,
-    getConnection: () => sqliteConnectionFactory(connectionOptions)
-  });
-};
-var sqliteAlwaysNewConnectionPool = (options) => {
-  const { driverType, sqliteConnectionFactory, connectionOptions } = options;
-  return _chunk4MMMEDQ7cjs.createAlwaysNewConnectionPool.call(void 0, {
-    driverType,
-    getConnection: () => sqliteConnectionFactory(connectionOptions)
-  });
-};
-var 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 _chunk4MMMEDQ7cjs.createAmbientConnectionPool.call(void 0, {
-      driverType,
-      connection: options.connection
-    });
-  if ("dual" in options && options.dual) {
-    return sqliteDualConnectionPool(
-      options
-    );
-  }
-  if (options.singleton === true && options.sqliteConnectionFactory) {
-    return _chunk4MMMEDQ7cjs.createSingletonConnectionPool.call(void 0, {
-      driverType,
-      getConnection: () => options.sqliteConnectionFactory(
-        options.connectionOptions
-      )
-    });
-  }
-  return _chunk4MMMEDQ7cjs.createAlwaysNewConnectionPool.call(void 0, {
-    driverType,
-    getConnection: () => options.sqliteConnectionFactory(
-      options.connectionOptions
-    )
-  });
-}
-
-// src/storage/sqlite/core/schema/migrations.ts
-var DefaultSQLiteMigratorOptions = {};
-_chunk4MMMEDQ7cjs.registerDefaultMigratorOptions.call(void 0, "SQLite", DefaultSQLiteMigratorOptions);
-
-// src/storage/sqlite/core/index.ts
-var SQLiteDatabaseName = "SQLite";
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-exports.mapSqliteError = mapSqliteError; exports.sqliteFormatter = sqliteFormatter; exports.sqliteExecute = sqliteExecute; exports.sqliteSQLExecutor = sqliteSQLExecutor; exports.sqliteTransaction = sqliteTransaction; exports.SQLiteConnectionString = SQLiteConnectionString; exports.parsePragmasFromConnectionString = parsePragmasFromConnectionString; exports.isSQLiteError = isSQLiteError; exports.transactionNestingCounter = transactionNestingCounter; exports.sqliteAmbientClientConnection = sqliteAmbientClientConnection; exports.sqliteClientConnection = sqliteClientConnection; exports.sqlitePoolClientConnection = sqlitePoolClientConnection; exports.sqliteConnection = sqliteConnection; exports.InMemorySQLiteDatabase = InMemorySQLiteDatabase; exports.DEFAULT_SQLITE_PRAGMA_OPTIONS = DEFAULT_SQLITE_PRAGMA_OPTIONS; exports.isInMemoryDatabase = isInMemoryDatabase; exports.sqliteAmbientConnectionPool = sqliteAmbientConnectionPool; exports.sqliteSingletonConnectionPool = sqliteSingletonConnectionPool; exports.sqliteAlwaysNewConnectionPool = sqliteAlwaysNewConnectionPool; exports.toSqlitePoolOptions = toSqlitePoolOptions; exports.sqlitePool = sqlitePool; exports.DefaultSQLiteMigratorOptions = DefaultSQLiteMigratorOptions; exports.SQLiteDatabaseName = SQLiteDatabaseName;
-//# sourceMappingURL=chunk-JIZGCEPE.cjs.map