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

package/dist/sqlite3.d.ts

@@ -1,6 +1,6 @@
-import { a as SQLiteDriverType, B as SQLiteClientOptions, G as SQLiteFileNameOrConnectionString, i as SQLiteClientOrPoolClient, b as SQLiteConnectionOptions, $ as SQLiteTransaction, S as SQLiteClient, P as SQLitePoolOptions, Q as SQLitePool, C as SQLiteConnectionString } from './index-C2z_XBn6.js';
-export { A as AnySQLiteClientConnection, p as AnySQLiteConnection, o as AnySQLitePoolClientConnection, W as DefaultSQLiteMigratorOptions, I as InMemorySQLiteDatabase, N as SQLiteAlwaysNewConnectionPool, J as SQLiteAmbientConnectionPool, l as SQLiteClientConnection, q as SQLiteClientConnectionDefinitionOptions, h as SQLiteClientFactory, e as SQLiteCommandOptions, n as SQLiteConnection, s as SQLiteConnectionDefinitionOptions, t as SQLiteConnectionFactory, c as SQLiteDatabaseName, d as SQLiteDatabaseType, j as SQLiteError, f as SQLiteParameters, g as SQLitePoolClient, m as SQLitePoolClientConnection, r as SQLitePoolConnectionDefinitionOptions, R as SQLitePoolFactoryOptions, E as SQLiteSQLExecutor, L as SQLiteSingletonConnectionPool, v as SqliteAmbientClientConnectionOptions, T as TransactionNestingCounter, X as defaultPostgreSqlDatabase, H as isInMemoryDatabase, k as isSQLiteError, O as sqliteAlwaysNewConnectionPool, w as sqliteAmbientClientConnection, K as sqliteAmbientConnectionPool, x as sqliteClientConnection, z as sqliteConnection, D as sqliteExecute, _ as sqliteFormatter, V as sqlitePool, y as sqlitePoolClientConnection, F as sqliteSQLExecutor, M as sqliteSingletonConnectionPool, a0 as sqliteTransaction, Z as tableExists, Y as tableExistsSQL, U as toSqlitePoolOptions, u as transactionNestingCounter } from './index-C2z_XBn6.js';
-import { C as Connection, a as DatabaseTransactionOptions, d as DumboDatabaseDriver, e as Dumbo, S as SQLFormatter, M as MigratorOptions, f as DumboConnectionOptions } from './connectionString-B1wm0TFc.js';
+import { SQLiteClientOrPoolClient, SQLiteClientOptions, SQLiteFileNameOrConnectionString, SQLiteDriverType, SQLiteTransaction, SQLiteTransactionOptions, SQLiteConnectionOptions, SQLiteClient, SQLitePoolOptions, SQLitePool, AnySQLiteConnection, SQLiteConnectionString } from './sqlite.js';
+export { AnySQLiteClientConnection, AnySQLitePoolClientConnection, BatchSQLiteCommandOptions, DEFAULT_SQLITE_PRAGMA_OPTIONS, DefaultSQLiteMigratorOptions, InMemorySQLiteDatabase, SQLiteAlwaysNewConnectionPool, SQLiteAmbientConnectionPool, SQLiteClientConnection, SQLiteClientConnectionDefinitionOptions, SQLiteClientFactory, SQLiteCommandOptions, SQLiteConnection, SQLiteConnectionDefinitionOptions, SQLiteConnectionFactory, SQLiteDatabaseName, SQLiteDatabaseType, SQLiteError, SQLiteErrorMapper, SQLiteParameters, SQLitePoolClient, SQLitePoolClientConnection, SQLitePoolConnectionDefinitionOptions, SQLitePoolFactoryOptions, SQLitePragmaOptions, SQLiteSQLExecutor, SQLiteSingletonConnectionPool, SQLiteTransactionMode, SqliteAmbientClientConnectionOptions, TransactionNestingCounter, defaultSQLiteDatabase, isInMemoryDatabase, isSQLiteError, mapSqliteError, parsePragmasFromConnectionString, sqliteAlwaysNewConnectionPool, sqliteAmbientClientConnection, sqliteAmbientConnectionPool, sqliteClientConnection, sqliteConnection, sqliteExecute, sqliteFormatter, sqliteMetadata, sqlitePool, sqlitePoolClientConnection, sqliteSQLExecutor, sqliteSingletonConnectionPool, sqliteTransaction, tableExists, toSqlitePoolOptions, transactionNestingCounter } from './sqlite.js';
+import { C as Connection, J as JSONSerializer, c as DumboConnectionOptions, d as DumboDatabaseDriver, e as ConnectionOptions, f as SQLFormatter, M as MigratorOptions, g as DatabaseMetadata } from './connectionString-Dch_MIRU.js';
 
 type SQLite3DriverType = SQLiteDriverType<'sqlite3'>;
 declare const SQLite3DriverType: SQLite3DriverType;
@@ -19,66 +19,86 @@ type SQLite3ConnectionOptions = SQLiteConnectionOptions & ((SQLite3ClientOptions
 }) | {
     client: SQLite3Client;
 });
-type SQLite3Connection<ClientType extends SQLiteClientOrPoolClient = SQLiteClientOrPoolClient> = Connection<SQLite3Connection, SQLite3DriverType, ClientType, SQLiteTransaction<SQLite3Connection>, DatabaseTransactionOptions>;
-declare const sqlite3Client: (options: SQLite3ClientOptions) => SQLiteClient;
-declare const checkConnection: (fileName: string) => Promise<ConnectionCheckResult>;
-declare const sqlite3Connection: (options: SQLite3ConnectionOptions) => SQLite3Connection<SQLiteClientOrPoolClient>;
+type SQLite3Connection<ClientType extends SQLiteClientOrPoolClient = SQLiteClientOrPoolClient> = Connection<SQLite3Connection, SQLite3DriverType, ClientType, SQLiteTransaction<SQLite3Connection, SQLiteTransactionOptions>>;
+declare const sqlite3Client: (options: SQLite3ClientOptions & {
+    serializer: JSONSerializer;
+}) => SQLiteClient;
+declare const checkConnection: (fileName: string, serializer: JSONSerializer) => Promise<ConnectionCheckResult>;
+declare const sqlite3Connection: (options: SQLite3ConnectionOptions & {
+    serializer: JSONSerializer;
+}) => SQLite3Connection<SQLiteClientOrPoolClient>;
 
-type SQLite3DumboOptions = Omit<SQLitePoolOptions<SQLite3Connection, SQLite3ConnectionOptions>, 'driverType'> & SQLite3ConnectionOptions;
+type SQLite3DumboOptions = Omit<SQLitePoolOptions<SQLite3Connection, SQLite3ConnectionOptions>, 'driverType'> & SQLite3ConnectionOptions & {
+    serializer?: JSONSerializer;
+};
+type SQLite3PoolOptions = SQLite3DumboOptions;
+type Sqlite3Pool = SQLitePool<SQLite3Connection>;
 declare const sqlite3Pool: (options: SQLite3DumboOptions) => SQLitePool<SQLite3Connection>;
-declare const sqlite3DatabaseDriver: {
+declare const sqlite3DumboDriver: {
     driverType: "SQLite:sqlite3";
     createPool: (options: ({
-        driver?: DumboDatabaseDriver<SQLite3Connection, SQLite3DumboOptions, Dumbo<"SQLite:sqlite3", SQLite3Connection>>;
+        driver?: DumboDatabaseDriver<SQLite3Connection, SQLite3DumboOptions, Sqlite3Pool>;
         driverType?: "SQLite:sqlite3";
-    } & Omit<Omit<SQLitePoolOptions<SQLite3Connection, SQLite3ConnectionOptions>, "driverType"> & SQLiteConnectionOptions & {
+    } & Omit<Omit<SQLitePoolOptions<SQLite3Connection, SQLite3ConnectionOptions>, "driverType"> & ConnectionOptions<AnySQLiteConnection> & SQLiteClientOptions & {
         fileName: string | SQLiteConnectionString;
         connectionString?: never;
     } & {
         client?: never;
+    } & {
+        serializer?: JSONSerializer;
     }, "driverType" | "driver" | "connectionString">) | ({
-        driver?: DumboDatabaseDriver<SQLite3Connection, SQLite3DumboOptions, Dumbo<"SQLite:sqlite3", SQLite3Connection>>;
+        driver?: DumboDatabaseDriver<SQLite3Connection, SQLite3DumboOptions, Sqlite3Pool>;
         driverType?: "SQLite:sqlite3";
-    } & Omit<Omit<SQLitePoolOptions<SQLite3Connection, SQLite3ConnectionOptions>, "driverType"> & SQLiteConnectionOptions & {
+    } & Omit<Omit<SQLitePoolOptions<SQLite3Connection, SQLite3ConnectionOptions>, "driverType"> & ConnectionOptions<AnySQLiteConnection> & SQLiteClientOptions & {
         connectionString: string | SQLiteConnectionString;
         fileName?: never;
     } & {
         client?: never;
+    } & {
+        serializer?: JSONSerializer;
     }, "driverType" | "driver" | "connectionString">) | ({
-        driver?: DumboDatabaseDriver<SQLite3Connection, SQLite3DumboOptions, Dumbo<"SQLite:sqlite3", SQLite3Connection>>;
+        driver?: DumboDatabaseDriver<SQLite3Connection, SQLite3DumboOptions, Sqlite3Pool>;
         driverType?: "SQLite:sqlite3";
-    } & Omit<Omit<SQLitePoolOptions<SQLite3Connection, SQLite3ConnectionOptions>, "driverType"> & SQLiteConnectionOptions & {
+    } & Omit<Omit<SQLitePoolOptions<SQLite3Connection, SQLite3ConnectionOptions>, "driverType"> & ConnectionOptions<AnySQLiteConnection> & SQLiteClientOptions & {
         client: SQLite3Client;
+    } & {
+        serializer?: JSONSerializer;
     }, "driverType" | "driver" | "connectionString">)) => SQLitePool<SQLite3Connection>;
     sqlFormatter: SQLFormatter;
     defaultMigratorOptions: MigratorOptions;
-    getDatabaseNameOrDefault: () => SQLiteConnectionString;
     canHandle: (options: ({
-        driver?: DumboDatabaseDriver<SQLite3Connection, SQLite3DumboOptions, Dumbo<"SQLite:sqlite3", SQLite3Connection>>;
+        driver?: DumboDatabaseDriver<SQLite3Connection, SQLite3DumboOptions, Sqlite3Pool>;
         driverType?: "SQLite:sqlite3";
-    } & Omit<Omit<SQLitePoolOptions<SQLite3Connection, SQLite3ConnectionOptions>, "driverType"> & SQLiteConnectionOptions & {
+    } & Omit<Omit<SQLitePoolOptions<SQLite3Connection, SQLite3ConnectionOptions>, "driverType"> & ConnectionOptions<AnySQLiteConnection> & SQLiteClientOptions & {
         fileName: string | SQLiteConnectionString;
         connectionString?: never;
     } & {
         client?: never;
+    } & {
+        serializer?: JSONSerializer;
     }, "driverType" | "driver" | "connectionString">) | ({
-        driver?: DumboDatabaseDriver<SQLite3Connection, SQLite3DumboOptions, Dumbo<"SQLite:sqlite3", SQLite3Connection>>;
+        driver?: DumboDatabaseDriver<SQLite3Connection, SQLite3DumboOptions, Sqlite3Pool>;
         driverType?: "SQLite:sqlite3";
-    } & Omit<Omit<SQLitePoolOptions<SQLite3Connection, SQLite3ConnectionOptions>, "driverType"> & SQLiteConnectionOptions & {
+    } & Omit<Omit<SQLitePoolOptions<SQLite3Connection, SQLite3ConnectionOptions>, "driverType"> & ConnectionOptions<AnySQLiteConnection> & SQLiteClientOptions & {
         connectionString: string | SQLiteConnectionString;
         fileName?: never;
     } & {
         client?: never;
+    } & {
+        serializer?: JSONSerializer;
     }, "driverType" | "driver" | "connectionString">) | ({
-        driver?: DumboDatabaseDriver<SQLite3Connection, SQLite3DumboOptions, Dumbo<"SQLite:sqlite3", SQLite3Connection>>;
+        driver?: DumboDatabaseDriver<SQLite3Connection, SQLite3DumboOptions, Sqlite3Pool>;
         driverType?: "SQLite:sqlite3";
-    } & Omit<Omit<SQLitePoolOptions<SQLite3Connection, SQLite3ConnectionOptions>, "driverType"> & SQLiteConnectionOptions & {
+    } & Omit<Omit<SQLitePoolOptions<SQLite3Connection, SQLite3ConnectionOptions>, "driverType"> & ConnectionOptions<AnySQLiteConnection> & SQLiteClientOptions & {
         client: SQLite3Client;
+    } & {
+        serializer?: JSONSerializer;
     }, "driverType" | "driver" | "connectionString">)) => boolean;
+    databaseMetadata: DatabaseMetadata<false, false, false>;
 };
-declare const useSqlite3DatabaseDriver: () => void;
-type SQLite3DumboConnectionOptions = DumboConnectionOptions<typeof sqlite3DatabaseDriver> & {
+declare const useSqlite3DumboDriver: () => void;
+type SQLite3DumboConnectionOptions = DumboConnectionOptions<typeof sqlite3DumboDriver> & {
     connectionString: string | SQLiteConnectionString;
 };
 
-export { type ConnectionCheckResult, type SQLite3Client, type SQLite3ClientOptions, type SQLite3Connection, type SQLite3ConnectionOptions, SQLite3DriverType, type SQLite3DumboConnectionOptions, type SQLite3DumboOptions, SQLiteClient, SQLiteClientOptions, SQLiteClientOrPoolClient, SQLiteConnectionOptions, SQLiteConnectionString, SQLiteDriverType, SQLiteFileNameOrConnectionString, SQLitePool, SQLitePoolOptions, SQLiteTransaction, checkConnection, sqlite3Pool as connectionPool, sqlite3DatabaseDriver as databaseDriver, sqlite3Client, sqlite3Connection, sqlite3DatabaseDriver, sqlite3Pool, sqlite3Client as sqliteClient, useSqlite3DatabaseDriver };
+export { AnySQLiteConnection, type ConnectionCheckResult, type SQLite3Client, type SQLite3ClientOptions, type SQLite3Connection, type SQLite3ConnectionOptions, SQLite3DriverType, type SQLite3DumboConnectionOptions, type SQLite3DumboOptions, type SQLite3PoolOptions, SQLiteClient, SQLiteClientOptions, SQLiteClientOrPoolClient, SQLiteConnectionOptions, SQLiteConnectionString, SQLiteDriverType, SQLiteFileNameOrConnectionString, SQLitePool, SQLitePoolOptions, SQLiteTransaction, SQLiteTransactionOptions, type Sqlite3Pool, checkConnection, sqlite3Client, sqlite3Connection, sqlite3DumboDriver, sqlite3Pool, useSqlite3DumboDriver };

package/dist/sqlite3.js

@@ -1,20 +1,13 @@
 import {
-  SQLite3DriverType,
-  checkConnection,
-  sqlite3Client,
-  sqlite3Connection,
-  sqlite3DatabaseDriver,
-  sqlite3Pool,
-  useSqlite3DatabaseDriver
-} from "./chunk-F7JQ7BX7.js";
-import {
+  DEFAULT_SQLITE_PRAGMA_OPTIONS,
   DefaultSQLiteMigratorOptions,
   InMemorySQLiteDatabase,
   SQLiteConnectionString,
   SQLiteDatabaseName,
-  defaultPostgreSqlDatabase,
   isInMemoryDatabase,
   isSQLiteError,
+  mapSqliteError,
+  parsePragmasFromConnectionString,
   sqliteAlwaysNewConnectionPool,
   sqliteAmbientClientConnection,
   sqliteAmbientConnectionPool,
@@ -27,46 +20,366 @@ import {
   sqliteSQLExecutor,
   sqliteSingletonConnectionPool,
   sqliteTransaction,
-  tableExists,
-  tableExistsSQL,
   toSqlitePoolOptions,
   transactionNestingCounter
-} from "./chunk-XVV3OOQX.js";
-import "./chunk-TXSETOGH.js";
-import "./chunk-N7RWT46K.js";
+} from "./chunk-XFEGS3YT.js";
+import {
+  defaultSQLiteDatabase,
+  sqliteMetadata,
+  tableExists
+} from "./chunk-WLWELSA2.js";
+import {
+  BatchCommandNoChangesError,
+  JSONSerializer,
+  SQL,
+  canHandleDriverWithConnectionString,
+  dumboDatabaseDriverRegistry
+} from "./chunk-JKE6SULM.js";
+
+// src/storage/sqlite/sqlite3/connections/connection.ts
+import sqlite3 from "sqlite3";
+
+// src/storage/sqlite/core/connections/pragmas.ts
+var mergePragmaOptions = (connectionString, userOptions) => {
+  const connectionStringPragmas = parsePragmasFromConnectionString(connectionString);
+  return {
+    ...DEFAULT_SQLITE_PRAGMA_OPTIONS,
+    ...connectionStringPragmas,
+    ...userOptions
+  };
+};
+var buildConnectionPragmaStatements = (pragmas) => [
+  // busy_timeout FIRST - enables waiting on locks for subsequent operations
+  { 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 }
+];
+var buildDatabasePragmaStatements = (pragmas) => [
+  { pragma: "journal_mode", value: pragmas.journal_mode }
+];
+
+// src/storage/sqlite/sqlite3/connections/connection.ts
+var SQLite3DriverType = "SQLite:sqlite3";
+var applyPragma = (database, pragma, value) => {
+  return new Promise((resolve, reject) => {
+    database.run(`PRAGMA ${pragma} = ${value};`, (err) => {
+      if (err) reject(err);
+      else resolve();
+    });
+  });
+};
+var queryPragma = (database, pragma) => new Promise((resolve, reject) => {
+  database.get(
+    `PRAGMA ${pragma};`,
+    (err, row) => {
+      if (err) reject(err);
+      else resolve(row?.[pragma] ?? "");
+    }
+  );
+});
+var applyPragmas = (database, pragmas) => pragmas.reduce(
+  (promise, { pragma, value }) => promise.then(() => applyPragma(database, pragma, value)),
+  Promise.resolve()
+);
+var 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) {
+              const current = await queryPragma(db, pragma);
+              if (current.toUpperCase() !== String(value).toUpperCase()) {
+                await applyPragma(db, pragma, value);
+              }
+            }
+          }).then(() => resolve()).catch(reject);
+        }
+      );
+    } 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 ?? []
+            });
+          }
+        );
+        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);
+    }
+  });
+  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, options2) => {
+      try {
+        const { query, params } = sqliteFormatter.format(sql, {
+          serializer
+        });
+        return await executeCommand(
+          query,
+          params,
+          options2
+        );
+      } catch (error) {
+        throw mapSqliteError(error);
+      }
+    },
+    batchCommand: async (sqls, options2) => {
+      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,
+            options2
+          );
+          results.push(result);
+          if (options2?.assertChanges && (result.rowCount ?? 0) === 0) {
+            throw new BatchCommandNoChangesError(i);
+          }
+        }
+        return results;
+      } catch (error) {
+        throw mapSqliteError(error);
+      }
+    }
+  };
+};
+var 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,
+      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,
+        serializer: options.serializer ?? JSONSerializer
+      })
+    }
+  })
+);
+var tryParseConnectionString = (connectionString) => {
+  try {
+    return SQLiteConnectionString(connectionString);
+  } catch {
+    return null;
+  }
+};
+var sqlite3DumboDriver = {
+  driverType: SQLite3DriverType,
+  createPool: (options) => sqlite3Pool(options),
+  sqlFormatter: sqliteFormatter,
+  defaultMigratorOptions: DefaultSQLiteMigratorOptions,
+  canHandle: canHandleDriverWithConnectionString(
+    SQLite3DriverType,
+    tryParseConnectionString
+  ),
+  databaseMetadata: sqliteMetadata
+};
+var useSqlite3DumboDriver = () => {
+  dumboDatabaseDriverRegistry.register(SQLite3DriverType, sqlite3DumboDriver);
+};
+useSqlite3DumboDriver();
 export {
+  DEFAULT_SQLITE_PRAGMA_OPTIONS,
   DefaultSQLiteMigratorOptions,
   InMemorySQLiteDatabase,
   SQLite3DriverType,
   SQLiteConnectionString,
   SQLiteDatabaseName,
   checkConnection,
-  sqlite3Pool as connectionPool,
-  sqlite3DatabaseDriver as databaseDriver,
-  defaultPostgreSqlDatabase,
+  defaultSQLiteDatabase,
   isInMemoryDatabase,
   isSQLiteError,
+  mapSqliteError,
+  parsePragmasFromConnectionString,
   sqlite3Client,
   sqlite3Connection,
-  sqlite3DatabaseDriver,
+  sqlite3DumboDriver,
   sqlite3Pool,
   sqliteAlwaysNewConnectionPool,
   sqliteAmbientClientConnection,
   sqliteAmbientConnectionPool,
-  sqlite3Client as sqliteClient,
   sqliteClientConnection,
   sqliteConnection,
   sqliteExecute,
   sqliteFormatter,
+  sqliteMetadata,
   sqlitePool,
   sqlitePoolClientConnection,
   sqliteSQLExecutor,
   sqliteSingletonConnectionPool,
   sqliteTransaction,
   tableExists,
-  tableExistsSQL,
   toSqlitePoolOptions,
   transactionNestingCounter,
-  useSqlite3DatabaseDriver
+  useSqlite3DumboDriver
 };
 //# sourceMappingURL=sqlite3.js.map

package/dist/sqlite3.js.map

@@ -1 +1 @@
-{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}
+{"version":3,"sources":["../src/storage/sqlite/sqlite3/connections/connection.ts","../src/storage/sqlite/core/connections/pragmas.ts","../src/storage/sqlite/sqlite3/index.ts"],"sourcesContent":["import sqlite3 from 'sqlite3';\nimport type { JSONSerializer } from '../../../../core';\nimport {\n  BatchCommandNoChangesError,\n  SQL,\n  type Connection,\n  type QueryResult,\n  type QueryResultRow,\n  type SQLQueryOptions,\n} from '../../../../core';\nimport { mapSqliteError } from '../../core/errors/errorMapper';\nimport type {\n  SQLiteClient,\n  SQLiteClientOrPoolClient,\n  SQLiteConnectionOptions,\n  SQLiteDriverType,\n  SQLiteFileNameOrConnectionString,\n  SQLiteTransaction,\n  SQLiteTransactionOptions,\n} from '../../core';\nimport {\n  DEFAULT_SQLITE_PRAGMA_OPTIONS,\n  InMemorySQLiteDatabase,\n  sqliteConnection,\n  type BatchSQLiteCommandOptions,\n  type SQLiteClientOptions,\n  type SQLiteCommandOptions,\n  type SQLiteParameters,\n} from '../../core/connections';\nimport {\n  buildConnectionPragmaStatements,\n  buildDatabasePragmaStatements,\n  mergePragmaOptions,\n} from '../../core/connections/pragmas';\nimport { sqliteFormatter } from '../../core/sql/formatter';\n\nexport type SQLite3DriverType = SQLiteDriverType<'sqlite3'>;\nexport const SQLite3DriverType: SQLite3DriverType = 'SQLite:sqlite3';\n\nexport type ConnectionCheckResult =\n  | { successful: true }\n  | {\n      successful: false;\n      code: string | undefined;\n      errorType: 'ConnectionRefused' | 'Authentication' | 'Unknown';\n      error: unknown;\n    };\n\nexport type SQLite3ClientOptions = SQLiteClientOptions &\n  SQLiteFileNameOrConnectionString;\n\nexport type SQLite3Client = SQLiteClientOrPoolClient;\n\nexport type SQLite3ConnectionOptions = SQLiteConnectionOptions &\n  ((SQLite3ClientOptions & { client?: never }) | { client: SQLite3Client });\n\nexport type SQLite3Connection<\n  ClientType extends SQLiteClientOrPoolClient = SQLiteClientOrPoolClient,\n> = Connection<\n  SQLite3Connection,\n  SQLite3DriverType,\n  ClientType,\n  SQLiteTransaction<SQLite3Connection, SQLiteTransactionOptions>\n>;\n\nconst applyPragma = (\n  database: sqlite3.Database,\n  pragma: string,\n  value: string | number,\n) => {\n  return new Promise<void>((resolve, reject) => {\n    database.run(`PRAGMA ${pragma} = ${value};`, (err) => {\n      if (err) reject(err);\n      else resolve();\n    });\n  });\n};\n\nconst queryPragma = (\n  database: sqlite3.Database,\n  pragma: string,\n): Promise<string> =>\n  new Promise((resolve, reject) => {\n    database.get(\n      `PRAGMA ${pragma};`,\n      (err: Error | null, row: { [key: string]: string } | null) => {\n        if (err) reject(err);\n        else resolve(row?.[pragma] ?? '');\n      },\n    );\n  });\n\nconst applyPragmas = (\n  database: sqlite3.Database,\n  pragmas: Array<{ pragma: string; value: string | number }>,\n) =>\n  pragmas.reduce(\n    (promise, { pragma, value }) =>\n      promise.then(() => applyPragma(database, pragma, value)),\n    Promise.resolve(),\n  );\n\nexport const sqlite3Client = (\n  options: SQLite3ClientOptions & {\n    serializer: JSONSerializer;\n  },\n): SQLiteClient => {\n  let db: sqlite3.Database;\n\n  let isClosed = false;\n\n  const { serializer } = options;\n\n  const connectionString =\n    options.fileName ?? options.connectionString ?? InMemorySQLiteDatabase;\n\n  const finalPragmas = mergePragmaOptions(\n    String(connectionString),\n    options.pragmaOptions,\n  );\n\n  const connectionPragmas = buildConnectionPragmaStatements(finalPragmas);\n\n  const connect: () => Promise<void> = () =>\n    db\n      ? Promise.resolve()\n      : new Promise((resolve, reject) => {\n          try {\n            db = new sqlite3.Database(\n              connectionString,\n              sqlite3.OPEN_URI | sqlite3.OPEN_READWRITE | sqlite3.OPEN_CREATE,\n              (err) => {\n                if (err) {\n                  reject(err);\n                  return;\n                }\n\n                const busyTimeout =\n                  finalPragmas.busy_timeout ??\n                  DEFAULT_SQLITE_PRAGMA_OPTIONS.busy_timeout!;\n\n                db.configure('busyTimeout', busyTimeout);\n\n                applyPragmas(\n                  db,\n                  connectionPragmas.filter((p) => p.pragma !== 'busy_timeout'),\n                )\n                  .then(async () => {\n                    if (options.skipDatabasePragmas) return;\n\n                    const databasePragmas =\n                      buildDatabasePragmaStatements(finalPragmas);\n                    for (const { pragma, value } of databasePragmas) {\n                      const current = await queryPragma(db, pragma);\n                      if (\n                        current.toUpperCase() !== String(value).toUpperCase()\n                      ) {\n                        await applyPragma(db, pragma, value);\n                      }\n                    }\n                  })\n                  .then(() => resolve())\n                  .catch(reject);\n              },\n            );\n\n            // Apply connection-level pragmas first (busy_timeout is first)\n          } catch (error) {\n            reject(error as Error);\n          }\n        });\n\n  const executeQuery = <T>(\n    sql: string,\n    params?: SQLiteParameters[],\n  ): Promise<T[]> =>\n    new Promise((resolve, reject) => {\n      try {\n        db.all(sql, params ?? [], (err: Error | null, result: T[]) => {\n          if (err) {\n            reject(err);\n            return;\n          }\n\n          resolve(result);\n        });\n      } catch (error) {\n        reject(error as Error);\n      }\n    });\n\n  const executeCommand = <Result extends QueryResultRow = QueryResultRow>(\n    sql: string,\n    params?: SQLiteParameters[],\n    options?: SQLiteCommandOptions,\n  ): Promise<QueryResult<Result>> =>\n    new Promise((resolve, reject) => {\n      try {\n        if (options?.ignoreChangesCount === true) {\n          db.run(\n            sql,\n            params ?? [],\n            function (err: Error | null, rows: Result[]) {\n              if (err) {\n                reject(err);\n                return;\n              }\n              resolve({\n                rowCount: 0,\n                rows: rows ?? [],\n              });\n            },\n          );\n          return;\n        }\n        // OD: 2026-01-21\n        // This is needed as SQLite does not return changes count properly\n        // We need to query it separately with SELECT changes()\n        // This may be fixed eventually in sqlite3 library as Node.js team did here:\n        // https://github.com/nodejs/node/issues/57344\n        // But for now, we do it manually, as a workaround\n        // We also serialize it to avoid race conditions\n        db.serialize(() => {\n          let hasFailed = false;\n          let resultRows: Result[] = [];\n\n          db.all(sql, params ?? [], (err, rows: Result[]) => {\n            if (err) {\n              hasFailed = true;\n              return reject(err);\n            }\n            resultRows = rows;\n          });\n\n          db.get(\n            'SELECT changes() as changes',\n            (err, row: { changes: number } | null) => {\n              // If the first query failed, we exit immediately.\n              // The promise is already rejected; we don't want to touch it.\n              if (hasFailed) return;\n\n              if (err) return reject(err);\n\n              resolve({\n                rowCount: row?.changes ?? 0,\n                rows: resultRows,\n              });\n            },\n          );\n        });\n      } catch (error) {\n        reject(error as Error);\n      }\n    });\n\n  return {\n    connect,\n    close: async (): Promise<void> => {\n      if (isClosed) {\n        return;\n      }\n      isClosed = true;\n      if (db) {\n        try {\n          await new Promise<void>((resolve, reject) => {\n            db.close((err: Error | null) => {\n              if (err) {\n                reject(err);\n                return;\n              }\n              resolve();\n            });\n          });\n        } catch (error) {\n          throw mapSqliteError(error);\n        }\n      }\n    },\n    query: async <Result extends QueryResultRow = QueryResultRow>(\n      sql: SQL,\n      _options?: SQLQueryOptions,\n    ): Promise<QueryResult<Result>> => {\n      try {\n        const { query, params } = sqliteFormatter.format(sql, {\n          serializer,\n        });\n        const result = await executeQuery<Result>(\n          query,\n          params as SQLiteParameters[],\n        );\n        return { rowCount: result.length, rows: result };\n      } catch (error) {\n        throw mapSqliteError(error);\n      }\n    },\n    batchQuery: async <Result extends QueryResultRow = QueryResultRow>(\n      sqls: SQL[],\n      _options?: SQLQueryOptions,\n    ): Promise<QueryResult<Result>[]> => {\n      try {\n        const results: QueryResult<Result>[] = [];\n        for (const sql of sqls) {\n          const { query, params } = sqliteFormatter.format(sql, {\n            serializer,\n          });\n          const result = await executeQuery<Result>(\n            query,\n            params as SQLiteParameters[],\n          );\n          results.push({ rowCount: result.length, rows: result });\n        }\n        return results;\n      } catch (error) {\n        throw mapSqliteError(error);\n      }\n    },\n    command: async <Result extends QueryResultRow = QueryResultRow>(\n      sql: SQL,\n      options?: SQLiteCommandOptions,\n    ): Promise<QueryResult<Result>> => {\n      try {\n        const { query, params } = sqliteFormatter.format(sql, {\n          serializer,\n        });\n\n        return await executeCommand<Result>(\n          query,\n          params as SQLiteParameters[],\n          options,\n        );\n      } catch (error) {\n        throw mapSqliteError(error);\n      }\n    },\n    batchCommand: async <Result extends QueryResultRow = QueryResultRow>(\n      sqls: SQL[],\n      options?: BatchSQLiteCommandOptions,\n    ): Promise<QueryResult<Result>[]> => {\n      try {\n        const results: QueryResult<Result>[] = [];\n\n        for (let i = 0; i < sqls.length; i++) {\n          const { query, params } = sqliteFormatter.format(sqls[i]!, {\n            serializer,\n          });\n          const result = await executeCommand<Result>(\n            query,\n            params as SQLiteParameters[],\n            options,\n          );\n          results.push(result);\n\n          if (options?.assertChanges && (result.rowCount ?? 0) === 0) {\n            throw new BatchCommandNoChangesError(i);\n          }\n        }\n        return results;\n      } catch (error) {\n        throw mapSqliteError(error);\n      }\n    },\n  };\n};\n\nexport const checkConnection = async (\n  fileName: string,\n  serializer: JSONSerializer,\n): Promise<ConnectionCheckResult> => {\n  const client = sqlite3Client({\n    fileName,\n    serializer,\n  });\n\n  try {\n    await client.query(SQL`SELECT 1`);\n    return { successful: true };\n  } catch (error) {\n    const code =\n      error instanceof Error &&\n      'code' in error &&\n      typeof error.code === 'string'\n        ? error.code\n        : undefined;\n\n    return {\n      successful: false,\n      errorType:\n        code === 'SQLITE_CANTOPEN'\n          ? 'ConnectionRefused'\n          : code === 'SQLITE_AUTH'\n            ? 'Authentication'\n            : 'Unknown',\n      code,\n      error,\n    };\n  } finally {\n    await client.close();\n  }\n};\n\nexport const sqlite3Connection = (\n  options: SQLite3ConnectionOptions & { serializer: JSONSerializer },\n) =>\n  sqliteConnection<SQLite3Connection, SQLite3ConnectionOptions>({\n    type: 'Client',\n    driverType: SQLite3DriverType,\n    sqliteClientFactory: (connectionOptions) => {\n      if ('client' in connectionOptions && connectionOptions.client) {\n        return connectionOptions.client;\n      }\n      return sqlite3Client({\n        ...connectionOptions,\n        serializer: options.serializer,\n      });\n    },\n    connectionOptions: options,\n    serializer: options.serializer,\n  });\n","import { parsePragmasFromConnectionString } from './connectionString';\nimport {\n  DEFAULT_SQLITE_PRAGMA_OPTIONS,\n  type SQLitePragmaOptions,\n} from './index';\n\nexport const mergePragmaOptions = (\n  connectionString: string,\n  userOptions?: Partial<SQLitePragmaOptions>,\n): SQLitePragmaOptions => {\n  const connectionStringPragmas =\n    parsePragmasFromConnectionString(connectionString);\n\n  return {\n    ...DEFAULT_SQLITE_PRAGMA_OPTIONS,\n    ...connectionStringPragmas,\n    ...userOptions,\n  };\n};\n\nexport const buildConnectionPragmaStatements = (\n  pragmas: SQLitePragmaOptions,\n): Array<{ pragma: string; value: string | number }> => [\n  // busy_timeout FIRST - enables waiting on locks for subsequent operations\n  { pragma: 'busy_timeout', value: pragmas.busy_timeout! },\n  { pragma: 'synchronous', value: pragmas.synchronous! },\n  { pragma: 'cache_size', value: pragmas.cache_size! },\n  { pragma: 'foreign_keys', value: pragmas.foreign_keys ? 'ON' : 'OFF' },\n  { pragma: 'temp_store', value: pragmas.temp_store! },\n];\n\nexport const buildDatabasePragmaStatements = (\n  pragmas: SQLitePragmaOptions,\n): Array<{ pragma: string; value: string | number }> => [\n  { pragma: 'journal_mode', value: pragmas.journal_mode! },\n];\n","export * from './connections';\nimport {\n  canHandleDriverWithConnectionString,\n  dumboDatabaseDriverRegistry,\n  JSONSerializer,\n  type DumboConnectionOptions,\n  type DumboDatabaseDriver,\n} from '../../../core';\nimport {\n  DefaultSQLiteMigratorOptions,\n  SQLiteConnectionString,\n  sqliteFormatter,\n  sqliteMetadata,\n  sqlitePool,\n  toSqlitePoolOptions,\n  type SQLitePool,\n  type SQLitePoolOptions,\n} from '../core';\nimport {\n  sqlite3Connection,\n  SQLite3DriverType,\n  type SQLite3Connection,\n  type SQLite3ConnectionOptions,\n} from './connections';\n\nexport type SQLite3DumboOptions = Omit<\n  SQLitePoolOptions<SQLite3Connection, SQLite3ConnectionOptions>,\n  'driverType'\n> &\n  SQLite3ConnectionOptions & { serializer?: JSONSerializer };\n\nexport type SQLite3PoolOptions = SQLite3DumboOptions;\n\nexport type Sqlite3Pool = SQLitePool<SQLite3Connection>;\n\nexport const sqlite3Pool = (options: SQLite3DumboOptions) =>\n  sqlitePool(\n    toSqlitePoolOptions({\n      ...options,\n      driverType: SQLite3DriverType,\n      ...('connection' in options\n        ? {}\n        : {\n            connectionOptions: options as SQLite3ConnectionOptions,\n            sqliteConnectionFactory: (opts: SQLite3ConnectionOptions) =>\n              sqlite3Connection({\n                ...opts,\n                serializer: options.serializer ?? JSONSerializer,\n              }),\n          }),\n    }),\n  );\n\nconst tryParseConnectionString = (connectionString: string) => {\n  try {\n    return SQLiteConnectionString(connectionString);\n  } catch {\n    return null;\n  }\n};\n\nexport const sqlite3DumboDriver = {\n  driverType: SQLite3DriverType,\n  createPool: (options) => sqlite3Pool(options as SQLite3DumboOptions),\n  sqlFormatter: sqliteFormatter,\n  defaultMigratorOptions: DefaultSQLiteMigratorOptions,\n  canHandle: canHandleDriverWithConnectionString(\n    SQLite3DriverType,\n    tryParseConnectionString,\n  ),\n  databaseMetadata: sqliteMetadata,\n} satisfies DumboDatabaseDriver<\n  SQLite3Connection,\n  SQLite3DumboOptions,\n  Sqlite3Pool\n>;\n\nexport const useSqlite3DumboDriver = () => {\n  dumboDatabaseDriverRegistry.register(SQLite3DriverType, sqlite3DumboDriver);\n};\n\nexport type SQLite3DumboConnectionOptions = DumboConnectionOptions<\n  typeof sqlite3DumboDriver\n> & { connectionString: string | SQLiteConnectionString };\n\nuseSqlite3DumboDriver();\n\nexport * from './connections';\nexport * from './formatter';\nexport * from './transactions';\n"],"mappings":"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","names":["options"]}