@event-driven-io/dumbo 0.13.0-beta.3 → 0.13.0-beta.31

package/dist/chunk-XFEGS3YT.js

@@ -0,0 +1,706 @@
+import {
+  CheckViolationError,
+  ConnectionError,
+  DataError,
+  DeadlockError,
+  DumboError,
+  ForeignKeyViolationError,
+  InsufficientResourcesError,
+  IntegrityConstraintViolationError,
+  InvalidOperationError,
+  LockNotAvailableError,
+  NotNullViolationError,
+  SQL,
+  SQLFormatter,
+  SQLProcessorsRegistry,
+  SerializationError,
+  SystemError,
+  TaskProcessor,
+  UniqueConstraintError,
+  createAlwaysNewConnectionPool,
+  createAmbientConnection,
+  createAmbientConnectionPool,
+  createBoundedConnectionPool,
+  createConnection,
+  createSingletonConnectionPool,
+  defaultProcessorsRegistry,
+  mapDefaultSQLColumnProcessors,
+  mapSQLQueryResult,
+  registerDefaultMigratorOptions,
+  registerFormatter,
+  sqlExecutor,
+  tracer
+} from "./chunk-JKE6SULM.js";
+
+// 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 = message?.toUpperCase() ?? "";
+  if (upperMessage.includes("UNIQUE") || upperMessage.includes("PRIMARY KEY"))
+    return new UniqueConstraintError(message, innerError);
+  if (upperMessage.includes("FOREIGN KEY"))
+    return new ForeignKeyViolationError(message, innerError);
+  if (upperMessage.includes("NOT NULL"))
+    return new NotNullViolationError(message, innerError);
+  if (upperMessage.includes("CHECK"))
+    return new CheckViolationError(message, innerError);
+  return new IntegrityConstraintViolationError(message, innerError);
+};
+var mapSqliteError = (error) => {
+  if (DumboError.isInstanceOf(error)) return error;
+  const code = getSqliteErrorCode(error);
+  if (!code)
+    return new 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 LockNotAvailableError(message, innerError);
+    // SQLITE_LOCKED (6): conflict within the same connection or shared cache
+    case "SQLITE_LOCKED":
+      return new DeadlockError(message, innerError);
+    // SQLITE_PROTOCOL (15): WAL locking race condition
+    case "SQLITE_PROTOCOL":
+      return new LockNotAvailableError(message, innerError);
+    // ── Connection / open errors ──
+    // SQLITE_CANTOPEN (14): unable to open database file
+    case "SQLITE_CANTOPEN":
+      return new ConnectionError(message, innerError);
+    // SQLITE_NOTADB (26): file is not a database
+    case "SQLITE_NOTADB":
+      return new ConnectionError(message, innerError);
+    // ── Resource exhaustion ──
+    // SQLITE_NOMEM (7): out of memory
+    case "SQLITE_NOMEM":
+      return new InsufficientResourcesError(message, innerError);
+    // SQLITE_FULL (13): disk full
+    case "SQLITE_FULL":
+      return new InsufficientResourcesError(message, innerError);
+    // ── System / I/O errors ──
+    // SQLITE_IOERR (10): operating system I/O error
+    case "SQLITE_IOERR":
+      return new SystemError(message, innerError);
+    // SQLITE_CORRUPT (11): database file is corrupted
+    case "SQLITE_CORRUPT":
+      return new SystemError(message, innerError);
+    // SQLITE_INTERNAL (2): internal SQLite malfunction
+    case "SQLITE_INTERNAL":
+      return new SystemError(message, innerError);
+    // SQLITE_NOLFS (22): large file support unavailable
+    case "SQLITE_NOLFS":
+      return new SystemError(message, innerError);
+    // ── Data errors ──
+    // SQLITE_TOOBIG (18): string or BLOB too large
+    case "SQLITE_TOOBIG":
+      return new DataError(message, innerError);
+    // SQLITE_MISMATCH (20): datatype mismatch
+    case "SQLITE_MISMATCH":
+      return new DataError(message, innerError);
+    // SQLITE_RANGE (25): bind parameter index out of range
+    case "SQLITE_RANGE":
+      return new DataError(message, innerError);
+    // ── Invalid operations ──
+    // SQLITE_ERROR (1): generic SQL error (syntax errors, missing tables, etc.)
+    case "SQLITE_ERROR":
+      return new InvalidOperationError(message, innerError);
+    // SQLITE_READONLY (8): attempt to write to a read-only database
+    case "SQLITE_READONLY":
+      return new InvalidOperationError(message, innerError);
+    // SQLITE_MISUSE (21): API misuse
+    case "SQLITE_MISUSE":
+      return new InvalidOperationError(message, innerError);
+    // SQLITE_AUTH (23): authorization denied
+    case "SQLITE_AUTH":
+      return new InvalidOperationError(message, innerError);
+    // SQLITE_PERM (3): access permission denied
+    case "SQLITE_PERM":
+      return new InvalidOperationError(message, innerError);
+    // SQLITE_SCHEMA (17): schema changed, statement needs re-preparation
+    case "SQLITE_SCHEMA":
+      return new InvalidOperationError(message, innerError);
+    // ── Transaction / abort ──
+    // SQLITE_ABORT (4): operation aborted (e.g. by rollback)
+    case "SQLITE_ABORT":
+      return new SerializationError(message, innerError);
+    // SQLITE_INTERRUPT (9): operation interrupted
+    case "SQLITE_INTERRUPT":
+      return new SerializationError(message, innerError);
+  }
+  return new 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 = mapDefaultSQLColumnProcessors(mapColumnType);
+
+// src/storage/sqlite/core/sql/formatter/index.ts
+var sqliteSQLProcessorsRegistry = SQLProcessorsRegistry({
+  from: defaultProcessorsRegistry
+}).register(sqliteColumnProcessors);
+var sqliteFormatter = SQLFormatter({
+  processorsRegistry: sqliteSQLProcessorsRegistry
+});
+registerFormatter("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) => {
+    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) => mapSQLQueryResult(row, options.mapping)
+          )
+        };
+      }
+      return result;
+    } catch (error) {
+      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) => mapSQLQueryResult(row, options.mapping)
+          )
+        }));
+      }
+      return results;
+    } catch (error) {
+      tracer.error("db:sql:batch_query:execute:error", { error });
+      throw (errorMapper ?? mapSqliteError)(error);
+    }
+  },
+  command: async (client, sql, options) => {
+    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) {
+      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) {
+      tracer.error("db:sql:batch_command:execute:error", { error });
+      throw (errorMapper ?? mapSqliteError)(error);
+    }
+  },
+  formatter: formatter ?? sqliteFormatter
+});
+
+// src/storage/sqlite/core/pool/dualPool.ts
+import { cpus } from "os";
+var sqliteDualConnectionPool = (options) => {
+  const { sqliteConnectionFactory, connectionOptions } = options;
+  const readerPoolSize = options.readerPoolSize ?? Math.max(4, cpus().length);
+  let databaseInitPromise = null;
+  const initTaskProcessor = new TaskProcessor({
+    maxActiveTasks: 1,
+    maxQueueSize: 1e3
+  });
+  const ensureDatabaseInitialized = async (connectionOptions2, retryCount = 0) => {
+    if (databaseInitPromise !== null) {
+      return databaseInitPromise;
+    }
+    return initTaskProcessor.enqueue(
+      async ({ ack }) => {
+        if (databaseInitPromise !== null) {
+          ack();
+          return databaseInitPromise;
+        }
+        const initConnection = sqliteConnectionFactory({
+          ...connectionOptions2,
+          skipDatabasePragmas: false,
+          readonly: false
+        });
+        const initPromise = initConnection.open();
+        databaseInitPromise = initPromise;
+        try {
+          await initPromise;
+          await initConnection.close();
+          ack();
+        } catch (error) {
+          databaseInitPromise = null;
+          await initConnection.close();
+          ack();
+          if (retryCount < 3) {
+            return ensureDatabaseInitialized(connectionOptions2, retryCount + 1);
+          }
+          throw mapSqliteError(error);
+        }
+      },
+      { taskGroupId: "db-init" }
+    );
+  };
+  const wrappedConnectionFactory = async (readonly, connectionOptions2) => {
+    await ensureDatabaseInitialized(connectionOptions2);
+    const connection = sqliteConnectionFactory({
+      ...connectionOptions2,
+      skipDatabasePragmas: true,
+      readonly
+    });
+    await connection.open();
+    return connection;
+  };
+  const writerPool = createSingletonConnectionPool({
+    driverType: options.driverType,
+    getConnection: () => wrappedConnectionFactory(false, connectionOptions)
+  });
+  const readerPool = createBoundedConnectionPool({
+    driverType: options.driverType,
+    getConnection: () => wrappedConnectionFactory(true, connectionOptions),
+    maxConnections: readerPoolSize
+  });
+  return {
+    driverType: options.driverType,
+    connection: (connectionOptions2) => connectionOptions2?.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) => connectionOptions2?.readonly ? readerPool.withConnection(handle, connectionOptions2) : writerPool.withConnection(handle, connectionOptions2),
+    transaction: writerPool.transaction,
+    withTransaction: writerPool.withTransaction,
+    close: () => Promise.all([writerPool.close(), readerPool.close()]).then(() => {
+    })
+  };
+};
+
+// 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 createAmbientConnectionPool({
+    driverType,
+    connection
+  });
+};
+var sqliteSingletonConnectionPool = (options) => {
+  const { driverType, sqliteConnectionFactory, connectionOptions } = options;
+  return createSingletonConnectionPool({
+    driverType,
+    getConnection: () => sqliteConnectionFactory(connectionOptions)
+  });
+};
+var sqliteAlwaysNewConnectionPool = (options) => {
+  const { driverType, sqliteConnectionFactory, connectionOptions } = options;
+  return createAlwaysNewConnectionPool({
+    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 createAmbientConnectionPool({
+      driverType,
+      connection: options.connection
+    });
+  if ("dual" in options && options.dual) {
+    return sqliteDualConnectionPool(
+      options
+    );
+  }
+  if (options.singleton === true && options.sqliteConnectionFactory) {
+    return createSingletonConnectionPool({
+      driverType,
+      getConnection: () => options.sqliteConnectionFactory(
+        options.connectionOptions
+      )
+    });
+  }
+  return createAlwaysNewConnectionPool({
+    driverType,
+    getConnection: () => options.sqliteConnectionFactory(
+      options.connectionOptions
+    )
+  });
+}
+
+// src/storage/sqlite/core/schema/migrations.ts
+var DefaultSQLiteMigratorOptions = {};
+registerDefaultMigratorOptions("SQLite", DefaultSQLiteMigratorOptions);
+
+// src/storage/sqlite/core/index.ts
+var SQLiteDatabaseName = "SQLite";
+
+// 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);
+  }
+  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 createAmbientConnection({
+    driverType,
+    client,
+    initTransaction: initTransaction ?? ((connection) => sqliteTransaction(
+      driverType,
+      connection,
+      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 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: 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 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: 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
+};
+
+// src/storage/sqlite/core/transactions/index.ts
+var sqliteTransaction = (driverType, connection, allowNestedTransactions, serializer, defaultTransactionMode) => (getClient, options) => {
+  const transactionCounter = transactionNestingCounter();
+  allowNestedTransactions = options?.allowNestedTransactions ?? allowNestedTransactions;
+  const transaction = {
+    connection: connection(),
+    driverType,
+    begin: async function() {
+      const client = await getClient;
+      if (allowNestedTransactions) {
+        if (transactionCounter.level >= 1) {
+          transactionCounter.increment();
+          if (options?.useSavepoints) {
+            await client.query(
+              SQL`SAVEPOINT transaction${SQL.plain(transactionCounter.level.toString())}`
+            );
+          }
+          return;
+        }
+        transactionCounter.increment();
+      }
+      const mode = options?.mode ?? defaultTransactionMode ?? "IMMEDIATE";
+      await client.query(SQL`BEGIN ${SQL.plain(mode)} TRANSACTION`);
+    },
+    commit: async function() {
+      const client = await getClient;
+      try {
+        if (allowNestedTransactions) {
+          if (transactionCounter.level > 1) {
+            if (options?.useSavepoints) {
+              await client.query(
+                SQL`RELEASE transaction${SQL.plain(transactionCounter.level.toString())}`
+              );
+            }
+            transactionCounter.decrement();
+            return;
+          }
+          transactionCounter.reset();
+        }
+        await client.query(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.query(SQL`ROLLBACK`);
+      } finally {
+        if (options?.close)
+          await options?.close(
+            client,
+            error
+          );
+      }
+    },
+    execute: sqlExecutor(sqliteSQLExecutor(driverType, serializer), {
+      connect: () => getClient
+    }),
+    _transactionOptions: options ?? {}
+  };
+  return transaction;
+};
+
+export {
+  mapSqliteError,
+  sqliteFormatter,
+  sqliteExecute,
+  sqliteSQLExecutor,
+  sqliteTransaction,
+  SQLiteConnectionString,
+  parsePragmasFromConnectionString,
+  isSQLiteError,
+  transactionNestingCounter,
+  sqliteAmbientClientConnection,
+  sqliteClientConnection,
+  sqlitePoolClientConnection,
+  sqliteConnection,
+  InMemorySQLiteDatabase,
+  DEFAULT_SQLITE_PRAGMA_OPTIONS,
+  isInMemoryDatabase,
+  sqliteAmbientConnectionPool,
+  sqliteSingletonConnectionPool,
+  sqliteAlwaysNewConnectionPool,
+  toSqlitePoolOptions,
+  sqlitePool,
+  DefaultSQLiteMigratorOptions,
+  SQLiteDatabaseName
+};
+//# sourceMappingURL=chunk-XFEGS3YT.js.map