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

package/dist/cloudflare.js

@@ -1,456 +1,365 @@
-import {
-  DEFAULT_SQLITE_PRAGMA_OPTIONS,
-  DefaultSQLiteMigratorOptions,
-  InMemorySQLiteDatabase,
-  SQLiteConnectionString,
-  SQLiteDatabaseName,
-  isInMemoryDatabase,
-  isSQLiteError,
-  mapSqliteError,
-  parsePragmasFromConnectionString,
-  sqliteAlwaysNewConnectionPool,
-  sqliteAmbientClientConnection,
-  sqliteAmbientConnectionPool,
-  sqliteClientConnection,
-  sqliteConnection,
-  sqliteExecute,
-  sqliteFormatter,
-  sqlitePool,
-  sqlitePoolClientConnection,
-  sqliteSQLExecutor,
-  sqliteSingletonConnectionPool,
-  sqliteTransaction,
-  toSqlitePoolOptions,
-  transactionNestingCounter
-} from "./chunk-6HAHSSPW.js";
-import {
-  defaultSQLiteDatabase,
-  sqliteMetadata,
-  tableExists
-} from "./chunk-UK7MXVS2.js";
-import {
-  BatchCommandNoChangesError,
-  CheckViolationError,
-  ConnectionError,
-  DataError,
-  DeadlockError,
-  DumboError,
-  ForeignKeyViolationError,
-  InsufficientResourcesError,
-  IntegrityConstraintViolationError,
-  InvalidOperationError,
-  JSONSerializer,
-  LockNotAvailableError,
-  NotNullViolationError,
-  SerializationError,
-  SystemError,
-  UniqueConstraintError,
-  createSingletonConnectionPool,
-  dumboDatabaseDriverRegistry,
-  sqlExecutor,
-  tracer
-} from "./chunk-H2JBS7HM.js";
+import { B as LockNotAvailableError, I as ForeignKeyViolationError, K as UniqueConstraintError, L as InsufficientResourcesError, M as DataError, N as DeadlockError, On as dumboDatabaseDriverRegistry, P as DumboError, R as IntegrityConstraintViolationError, T as sqlExecutor, U as SerializationError, V as NotNullViolationError, W as SystemError, _ as BatchCommandNoChangesError, j as ConnectionError, k as CheckViolationError, o as createSingletonConnectionPool, rn as JSONSerializer, rt as tracer, z as InvalidOperationError } from "./core-DDo4m0Z_.js";
+import { n as defaultSQLiteDatabase, r as tableExists, t as sqliteMetadata } from "./sqliteMetadata-BoQ7Sc9I.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-BeyC5tHn.js";
 
-// src/storage/sqlite/d1/connections/d1Client.ts
-var d1Client = (options) => {
-  const { database, session, serializer } = options;
-  const execute = session ?? database;
-  return {
-    database,
-    session,
-    connect: () => Promise.resolve(),
-    close: () => Promise.resolve(),
-    withSession: async (constraintOrBookmark) => {
-      const newSession = constraintOrBookmark ? database.withSession(constraintOrBookmark) : database.withSession();
-      return Promise.resolve(
-        d1Client({
-          database,
-          session: newSession,
-          serializer
-        })
-      );
-    },
-    query: async (sql, _options) => {
-      const { query, params } = sqliteFormatter.format(sql, { serializer });
-      const stmt = execute.prepare(query);
-      const bound = params?.length ? stmt.bind(...params) : stmt;
-      const { results } = await bound.all();
-      return { rowCount: results?.length ?? 0, rows: results ?? [] };
-    },
-    batchQuery: async (sqls, _options) => {
-      const statements = sqls.map((sql) => {
-        const { query, params } = sqliteFormatter.format(sql, { serializer });
-        const stmt = execute.prepare(query);
-        return params?.length ? stmt.bind(...params) : stmt;
-      });
-      const results = await execute.batch(statements);
-      return results.map((result) => ({
-        rowCount: result.results?.length ?? 0,
-        rows: result.results ?? []
-      }));
-    },
-    command: async (sql, _options) => {
-      const { query, params } = sqliteFormatter.format(sql, { serializer });
-      const stmt = execute.prepare(query);
-      const bound = params?.length ? stmt.bind(...params) : stmt;
-      const result = await bound.run();
-      return {
-        rowCount: result.meta?.changes ?? 0,
-        rows: result.results ?? []
-      };
-    },
-    batchCommand: async (sqls, options2) => {
-      const statements = sqls.map((sql) => {
-        const { query, params } = sqliteFormatter.format(sql, { serializer });
-        const stmt = execute.prepare(query);
-        return params?.length ? stmt.bind(...params) : stmt;
-      });
-      const batchResults = await execute.batch(statements);
-      return batchResults.map((result, i) => {
-        const qr = {
-          rowCount: result.meta?.changes ?? 0,
-          rows: result.results ?? []
-        };
-        if (options2?.assertChanges && (qr.rowCount ?? 0) === 0) {
-          throw new BatchCommandNoChangesError(i);
-        }
-        return qr;
-      });
-    }
-  };
+//#region src/storage/sqlite/d1/connections/d1Client.ts
+const d1Client = (options) => {
+	const { database, session, serializer } = options;
+	const execute = session ?? database;
+	return {
+		database,
+		session,
+		connect: () => Promise.resolve(),
+		close: () => Promise.resolve(),
+		withSession: async (constraintOrBookmark) => {
+			const newSession = constraintOrBookmark ? database.withSession(constraintOrBookmark) : database.withSession();
+			return Promise.resolve(d1Client({
+				database,
+				session: newSession,
+				serializer
+			}));
+		},
+		query: async (sql, _options) => {
+			const { query, params } = sqliteFormatter.format(sql, { serializer });
+			const stmt = execute.prepare(query);
+			const { results } = await (params?.length ? stmt.bind(...params) : stmt).all();
+			return {
+				rowCount: results?.length ?? 0,
+				rows: results ?? []
+			};
+		},
+		batchQuery: async (sqls, _options) => {
+			const statements = sqls.map((sql) => {
+				const { query, params } = sqliteFormatter.format(sql, { serializer });
+				const stmt = execute.prepare(query);
+				return params?.length ? stmt.bind(...params) : stmt;
+			});
+			return (await execute.batch(statements)).map((result) => ({
+				rowCount: result.results?.length ?? 0,
+				rows: result.results ?? []
+			}));
+		},
+		command: async (sql, _options) => {
+			const { query, params } = sqliteFormatter.format(sql, { serializer });
+			const stmt = execute.prepare(query);
+			const result = await (params?.length ? stmt.bind(...params) : stmt).run();
+			return {
+				rowCount: result.meta?.changes ?? 0,
+				rows: result.results ?? []
+			};
+		},
+		batchCommand: async (sqls, options) => {
+			const statements = sqls.map((sql) => {
+				const { query, params } = sqliteFormatter.format(sql, { serializer });
+				const stmt = execute.prepare(query);
+				return params?.length ? stmt.bind(...params) : stmt;
+			});
+			return (await execute.batch(statements)).map((result, i) => {
+				const qr = {
+					rowCount: result.meta?.changes ?? 0,
+					rows: result.results ?? []
+				};
+				if (options?.assertChanges && (qr.rowCount ?? 0) === 0) throw new BatchCommandNoChangesError(i);
+				return qr;
+			});
+		}
+	};
 };
 
-// src/storage/sqlite/d1/errors/errorMapper.ts
-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);
+//#endregion
+//#region src/storage/sqlite/d1/errors/errorMapper.ts
+const getErrorMessage = (error) => error instanceof Error ? error.message : void 0;
+const asError = (error) => error instanceof Error ? error : void 0;
+/**
+* Determines the constraint subtype from the error message.
+*
+* D1 embeds the SQLite constraint detail in the message string, e.g.:
+*   "D1_ERROR: UNIQUE constraint failed: users.email"
+*   "D1_ERROR: SQLITE_CONSTRAINT: FOREIGN KEY constraint failed"
+*/
+const 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 isConstraintMessage = (upper) => upper.includes("CONSTRAINT") || upper.includes("UNIQUE") || upper.includes("PRIMARY KEY") || upper.includes("FOREIGN KEY") || upper.includes("NOT NULL");
-var SQLITE_CODE_RE = /SQLITE_([A-Z]+)/;
-var extractEmbeddedSqliteCode = (message) => {
-  const match = SQLITE_CODE_RE.exec(message);
-  return match ? `SQLITE_${match[1]}` : void 0;
+const isConstraintMessage = (upper) => upper.includes("CONSTRAINT") || upper.includes("UNIQUE") || upper.includes("PRIMARY KEY") || upper.includes("FOREIGN KEY") || upper.includes("NOT NULL");
+/** Extracts the first `SQLITE_<CODE>` token from a message string. */
+const SQLITE_CODE_RE = /SQLITE_([A-Z]+)/;
+const extractEmbeddedSqliteCode = (message) => {
+	const match = SQLITE_CODE_RE.exec(message);
+	return match ? `SQLITE_${match[1]}` : void 0;
 };
-var mapEmbeddedSqliteCode = (code, message, innerError) => {
-  switch (code) {
-    case "SQLITE_CONSTRAINT":
-      return mapConstraintError(message, innerError);
-    case "SQLITE_BUSY":
-      return new LockNotAvailableError(message, innerError);
-    case "SQLITE_LOCKED":
-      return new DeadlockError(message, innerError);
-    case "SQLITE_PROTOCOL":
-      return new LockNotAvailableError(message, innerError);
-    case "SQLITE_CANTOPEN":
-      return new ConnectionError(message, innerError);
-    case "SQLITE_NOTADB":
-      return new ConnectionError(message, innerError);
-    case "SQLITE_NOMEM":
-      return new InsufficientResourcesError(message, innerError);
-    case "SQLITE_FULL":
-      return new InsufficientResourcesError(message, innerError);
-    case "SQLITE_IOERR":
-      return new SystemError(message, innerError);
-    case "SQLITE_CORRUPT":
-      return new SystemError(message, innerError);
-    case "SQLITE_INTERNAL":
-      return new SystemError(message, innerError);
-    case "SQLITE_NOLFS":
-      return new SystemError(message, innerError);
-    case "SQLITE_TOOBIG":
-      return new DataError(message, innerError);
-    case "SQLITE_MISMATCH":
-      return new DataError(message, innerError);
-    case "SQLITE_RANGE":
-      return new DataError(message, innerError);
-    case "SQLITE_ERROR":
-      return new InvalidOperationError(message, innerError);
-    case "SQLITE_READONLY":
-      return new InvalidOperationError(message, innerError);
-    case "SQLITE_MISUSE":
-      return new InvalidOperationError(message, innerError);
-    case "SQLITE_AUTH":
-      return new InvalidOperationError(message, innerError);
-    case "SQLITE_PERM":
-      return new InvalidOperationError(message, innerError);
-    case "SQLITE_SCHEMA":
-      return new InvalidOperationError(message, innerError);
-    case "SQLITE_ABORT":
-      return new SerializationError(message, innerError);
-    case "SQLITE_INTERRUPT":
-      return new SerializationError(message, innerError);
-  }
-  return void 0;
+/**
+* Maps a `SQLITE_*` code found in the D1 message to a DumboError.
+*
+* D1 sometimes forwards raw SQLite result codes from the C++ layer, e.g.:
+*   "D1_ERROR: SQLITE_BUSY: database is locked"
+*   "SQLITE_READONLY: attempt to write a readonly database"
+*
+* See https://www.sqlite.org/rescode.html for the full code list.
+*/
+const mapEmbeddedSqliteCode = (code, message, innerError) => {
+	switch (code) {
+		case "SQLITE_CONSTRAINT": return mapConstraintError(message, innerError);
+		case "SQLITE_BUSY": return new LockNotAvailableError(message, innerError);
+		case "SQLITE_LOCKED": return new DeadlockError(message, innerError);
+		case "SQLITE_PROTOCOL": return new LockNotAvailableError(message, innerError);
+		case "SQLITE_CANTOPEN": return new ConnectionError(message, innerError);
+		case "SQLITE_NOTADB": return new ConnectionError(message, innerError);
+		case "SQLITE_NOMEM": return new InsufficientResourcesError(message, innerError);
+		case "SQLITE_FULL": return new InsufficientResourcesError(message, innerError);
+		case "SQLITE_IOERR": return new SystemError(message, innerError);
+		case "SQLITE_CORRUPT": return new SystemError(message, innerError);
+		case "SQLITE_INTERNAL": return new SystemError(message, innerError);
+		case "SQLITE_NOLFS": return new SystemError(message, innerError);
+		case "SQLITE_TOOBIG": return new DataError(message, innerError);
+		case "SQLITE_MISMATCH": return new DataError(message, innerError);
+		case "SQLITE_RANGE": return new DataError(message, innerError);
+		case "SQLITE_ERROR": return new InvalidOperationError(message, innerError);
+		case "SQLITE_READONLY": return new InvalidOperationError(message, innerError);
+		case "SQLITE_MISUSE": return new InvalidOperationError(message, innerError);
+		case "SQLITE_AUTH": return new InvalidOperationError(message, innerError);
+		case "SQLITE_PERM": return new InvalidOperationError(message, innerError);
+		case "SQLITE_SCHEMA": return new InvalidOperationError(message, innerError);
+		case "SQLITE_ABORT": return new SerializationError(message, innerError);
+		case "SQLITE_INTERRUPT": return new SerializationError(message, innerError);
+	}
 };
-var mapD1Error = (error) => {
-  if (DumboError.isInstanceOf(error)) return error;
-  const message = getErrorMessage(error);
-  if (!message)
-    return new DumboError({
-      errorCode: 500,
-      message: error instanceof Error ? error.message : String(error),
-      innerError: asError(error)
-    });
-  const innerError = asError(error);
-  const upper = message.toUpperCase();
-  if (upper.startsWith("D1_TYPE_ERROR"))
-    return new DataError(message, innerError);
-  if (upper.startsWith("D1_COLUMN_NOTFOUND"))
-    return new DataError(message, innerError);
-  if (upper.startsWith("D1_DUMP_ERROR"))
-    return new SystemError(message, innerError);
-  if (upper.startsWith("D1_SESSION_ERROR"))
-    return new ConnectionError(message, innerError);
-  if (isConstraintMessage(upper)) {
-    return mapConstraintError(message, innerError);
-  }
-  if (upper.includes("NETWORK CONNECTION LOST") || upper.includes("CANNOT RESOLVE D1 DB DUE TO TRANSIENT ISSUE") || upper.includes("D1 DB RESET BECAUSE"))
-    return new ConnectionError(message, innerError);
-  if (upper.includes("D1 DB IS OVERLOADED") || upper.includes("TOO MANY REQUESTS") || upper.includes("MEMORY LIMIT WOULD BE EXCEEDED"))
-    return new InsufficientResourcesError(message, innerError);
-  if (upper.startsWith("D1_ERROR") || upper.startsWith("D1_EXEC_ERROR")) {
-    const embeddedCode2 = extractEmbeddedSqliteCode(message);
-    if (embeddedCode2) {
-      const mapped = mapEmbeddedSqliteCode(embeddedCode2, message, innerError);
-      if (mapped) return mapped;
-    }
-    return new InvalidOperationError(message, innerError);
-  }
-  const embeddedCode = extractEmbeddedSqliteCode(message);
-  if (embeddedCode) {
-    const mapped = mapEmbeddedSqliteCode(embeddedCode, message, innerError);
-    if (mapped) return mapped;
-  }
-  return new DumboError({
-    errorCode: 500,
-    message,
-    innerError
-  });
+/**
+* Maps a Cloudflare D1 error to a typed DumboError.
+*
+* Unlike node-sqlite3, D1 throws **plain `Error` objects** with no `code`
+* property. All error information is embedded in `error.message`, using
+* well-known prefixes from the `workerd` runtime:
+*
+* | Prefix                | Meaning                                      |
+* |-----------------------|----------------------------------------------|
+* | `D1_ERROR:`           | General D1 / SQLite error                    |
+* | `D1_EXEC_ERROR:`      | Error during `.exec()` batch                 |
+* | `D1_TYPE_ERROR:`      | Type mismatch (e.g. `undefined` vs `null`)   |
+* | `D1_COLUMN_NOTFOUND`  | Referenced column does not exist              |
+* | `D1_DUMP_ERROR:`      | Error during database dump                   |
+* | `D1_SESSION_ERROR:`   | Session bookmark / constraint error           |
+*
+* D1 also surfaces platform-level messages (no prefix) for transient errors:
+*   - "Network connection lost."
+*   - "D1 DB is overloaded. Too many requests queued."
+*   - "Memory limit would be exceeded by this operation."
+*   - "Cannot resolve D1 DB due to transient issue on remote node."
+*   - "D1 DB reset because its code was updated."
+*
+* Reference:
+*   - https://developers.cloudflare.com/d1/platform/client-api/
+*   - https://github.com/cloudflare/workerd (src/cloudflare/internal/d1-api.ts)
+*
+* Falls back to a generic DumboError (500) if the error is not a recognized D1 error.
+*/
+const mapD1Error = (error) => {
+	if (DumboError.isInstanceOf(error)) return error;
+	const message = getErrorMessage(error);
+	if (!message) return new DumboError({
+		errorCode: 500,
+		message: error instanceof Error ? error.message : String(error),
+		innerError: asError(error)
+	});
+	const innerError = asError(error);
+	const upper = message.toUpperCase();
+	if (upper.startsWith("D1_TYPE_ERROR")) return new DataError(message, innerError);
+	if (upper.startsWith("D1_COLUMN_NOTFOUND")) return new DataError(message, innerError);
+	if (upper.startsWith("D1_DUMP_ERROR")) return new SystemError(message, innerError);
+	if (upper.startsWith("D1_SESSION_ERROR")) return new ConnectionError(message, innerError);
+	if (isConstraintMessage(upper)) return mapConstraintError(message, innerError);
+	if (upper.includes("NETWORK CONNECTION LOST") || upper.includes("CANNOT RESOLVE D1 DB DUE TO TRANSIENT ISSUE") || upper.includes("D1 DB RESET BECAUSE")) return new ConnectionError(message, innerError);
+	if (upper.includes("D1 DB IS OVERLOADED") || upper.includes("TOO MANY REQUESTS") || upper.includes("MEMORY LIMIT WOULD BE EXCEEDED")) return new InsufficientResourcesError(message, innerError);
+	if (upper.startsWith("D1_ERROR") || upper.startsWith("D1_EXEC_ERROR")) {
+		const embeddedCode = extractEmbeddedSqliteCode(message);
+		if (embeddedCode) {
+			const mapped = mapEmbeddedSqliteCode(embeddedCode, message, innerError);
+			if (mapped) return mapped;
+		}
+		return new InvalidOperationError(message, innerError);
+	}
+	const embeddedCode = extractEmbeddedSqliteCode(message);
+	if (embeddedCode) {
+		const mapped = mapEmbeddedSqliteCode(embeddedCode, message, innerError);
+		if (mapped) return mapped;
+	}
+	return new DumboError({
+		errorCode: 500,
+		message,
+		innerError
+	});
 };
 
-// src/storage/sqlite/d1/execute/d1SqlExecutor.ts
-var d1SQLExecutor = () => ({
-  driverType: "SQLite:d1",
-  formatter: sqliteFormatter,
-  query: async (client, sql, options) => {
-    try {
-      return await client.query(sql, options);
-    } catch (error) {
-      tracer.error("db:sql:query:execute:error", { error });
-      throw mapD1Error(error);
-    }
-  },
-  batchQuery: async (client, sqls, options) => {
-    try {
-      return await client.batchQuery(sqls, options);
-    } catch (error) {
-      tracer.error("db:sql:batch_query:execute:error", { error });
-      throw mapD1Error(error);
-    }
-  },
-  command: async (client, sql, options) => {
-    try {
-      return await client.command(sql, options);
-    } catch (error) {
-      tracer.error("db:sql:command:execute:error", { error });
-      throw mapD1Error(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 mapD1Error(error);
-    }
-  }
+//#endregion
+//#region src/storage/sqlite/d1/execute/d1SqlExecutor.ts
+const d1SQLExecutor = () => ({
+	driverType: "SQLite:d1",
+	formatter: sqliteFormatter,
+	query: async (client, sql, options) => {
+		try {
+			return await client.query(sql, options);
+		} catch (error) {
+			tracer.error("db:sql:query:execute:error", { error });
+			throw mapD1Error(error);
+		}
+	},
+	batchQuery: async (client, sqls, options) => {
+		try {
+			return await client.batchQuery(sqls, options);
+		} catch (error) {
+			tracer.error("db:sql:batch_query:execute:error", { error });
+			throw mapD1Error(error);
+		}
+	},
+	command: async (client, sql, options) => {
+		try {
+			return await client.command(sql, options);
+		} catch (error) {
+			tracer.error("db:sql:command:execute:error", { error });
+			throw mapD1Error(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 mapD1Error(error);
+		}
+	}
 });
 
-// src/storage/sqlite/d1/transactions/d1Transaction.ts
+//#endregion
+//#region src/storage/sqlite/d1/transactions/d1Transaction.ts
 var D1TransactionNotSupportedError = class extends Error {
-  constructor() {
-    super(
-      'D1 does not support SQL transactions (BEGIN/COMMIT/ROLLBACK/SAVEPOINT). Use { mode: "session_based" } to opt-in to session+batch semantics, or use connection.execute.batchCommand() for atomic multi-statement execution.'
-    );
-    this.name = "D1TransactionNotSupportedError";
-  }
+	constructor() {
+		super("D1 does not support SQL transactions (BEGIN/COMMIT/ROLLBACK/SAVEPOINT). Use { mode: \"session_based\" } to opt-in to session+batch semantics, or use connection.execute.batchCommand() for atomic multi-statement execution.");
+		this.name = "D1TransactionNotSupportedError";
+	}
 };
-var d1Transaction = (connection, serializer, defaultOptions) => (getClient, options) => {
-  const transactionCounter = transactionNestingCounter();
-  const allowNestedTransactions = options?.allowNestedTransactions ?? defaultOptions?.allowNestedTransactions;
-  const mode = options?.mode ?? defaultOptions?.mode;
-  let client = null;
-  let sessionClient = null;
-  const getDatabaseClient = async () => {
-    if (client) return Promise.resolve(client);
-    client = await getClient;
-    return client;
-  };
-  return {
-    connection: connection(),
-    driverType: D1DriverType,
-    begin: async function() {
-      if (mode !== "session_based") {
-        throw new D1TransactionNotSupportedError();
-      }
-      const client2 = await getDatabaseClient();
-      if (allowNestedTransactions) {
-        if (transactionCounter.level >= 1) {
-          transactionCounter.increment();
-          return;
-        }
-        transactionCounter.increment();
-      }
-      sessionClient = await client2.withSession(options?.d1Session);
-    },
-    commit: async function() {
-      const client2 = await getDatabaseClient();
-      try {
-        if (allowNestedTransactions) {
-          if (transactionCounter.level > 1) {
-            transactionCounter.decrement();
-            return;
-          }
-          transactionCounter.reset();
-        }
-        sessionClient = null;
-      } finally {
-        if (options?.close) await options?.close(client2);
-      }
-    },
-    rollback: async function(error) {
-      const client2 = await getDatabaseClient();
-      try {
-        if (allowNestedTransactions) {
-          if (transactionCounter.level > 1) {
-            transactionCounter.decrement();
-            return;
-          }
-        }
-        sessionClient = null;
-      } finally {
-        if (options?.close) await options?.close(client2, error);
-      }
-    },
-    execute: sqlExecutor(d1SQLExecutor(), {
-      connect: () => {
-        if (!sessionClient) {
-          throw new Error(
-            "Transaction has not been started. Call begin() first."
-          );
-        }
-        return Promise.resolve(sessionClient);
-      }
-    }),
-    _transactionOptions: options ?? {}
-  };
+const d1Transaction = (connection, serializer, defaultOptions) => (getClient, options) => {
+	const transactionCounter = transactionNestingCounter();
+	const allowNestedTransactions = options?.allowNestedTransactions ?? defaultOptions?.allowNestedTransactions;
+	const mode = options?.mode ?? defaultOptions?.mode;
+	let client = null;
+	let sessionClient = null;
+	const getDatabaseClient = async () => {
+		if (client) return Promise.resolve(client);
+		client = await getClient;
+		return client;
+	};
+	return {
+		connection: connection(),
+		driverType: D1DriverType,
+		begin: async function() {
+			if (mode !== "session_based") throw new D1TransactionNotSupportedError();
+			const client = await getDatabaseClient();
+			if (allowNestedTransactions) {
+				if (transactionCounter.level >= 1) {
+					transactionCounter.increment();
+					return;
+				}
+				transactionCounter.increment();
+			}
+			sessionClient = await client.withSession(options?.d1Session);
+		},
+		commit: async function() {
+			const client = await getDatabaseClient();
+			try {
+				if (allowNestedTransactions) {
+					if (transactionCounter.level > 1) {
+						transactionCounter.decrement();
+						return;
+					}
+					transactionCounter.reset();
+				}
+				sessionClient = null;
+			} finally {
+				if (options?.close) await options?.close(client);
+			}
+		},
+		rollback: async function(error) {
+			const client = await getDatabaseClient();
+			try {
+				if (allowNestedTransactions) {
+					if (transactionCounter.level > 1) {
+						transactionCounter.decrement();
+						return;
+					}
+				}
+				sessionClient = null;
+			} finally {
+				if (options?.close) await options?.close(client, error);
+			}
+		},
+		execute: sqlExecutor(d1SQLExecutor(), { connect: () => {
+			if (!sessionClient) throw new Error("Transaction has not been started. Call begin() first.");
+			return Promise.resolve(sessionClient);
+		} }),
+		_transactionOptions: options ?? {}
+	};
 };
 
-// src/storage/sqlite/d1/connections/d1Connection.ts
-var D1DriverType = "SQLite:d1";
-var d1Connection = (options) => {
-  const connection = options.connection ?? options.transaction?.connection ?? {
-    ...sqliteAmbientClientConnection({
-      driverType: D1DriverType,
-      client: options.client ?? d1Client(options),
-      initTransaction: (connection2) => d1Transaction(
-        connection2,
-        options.serializer,
-        options.transactionOptions
-      ),
-      serializer: options.serializer,
-      errorMapper: mapD1Error
-    })
-  };
-  connection.d1Session = async (constraintOrBookmark) => {
-    const client = await connection.open();
-    const sessionClient = await client.withSession(constraintOrBookmark);
-    return d1Connection({
-      ...options,
-      client: sessionClient
-    });
-  };
-  connection.withD1Session = async (handle, options2) => {
-    const sessionConnection = await connection.d1Session(options2);
-    try {
-      return await handle(sessionConnection);
-    } finally {
-      await sessionConnection.close();
-    }
-  };
-  return connection;
+//#endregion
+//#region src/storage/sqlite/d1/connections/d1Connection.ts
+const D1DriverType = "SQLite:d1";
+const d1Connection = (options) => {
+	const connection = options.connection ?? options.transaction?.connection ?? { ...sqliteAmbientClientConnection({
+		driverType: "SQLite:d1",
+		client: options.client ?? d1Client(options),
+		initTransaction: (connection) => d1Transaction(connection, options.serializer, options.transactionOptions),
+		serializer: options.serializer,
+		errorMapper: mapD1Error
+	}) };
+	connection.d1Session = async (constraintOrBookmark) => {
+		const sessionClient = await (await connection.open()).withSession(constraintOrBookmark);
+		return d1Connection({
+			...options,
+			client: sessionClient
+		});
+	};
+	connection.withD1Session = async (handle, options) => {
+		const sessionConnection = await connection.d1Session(options);
+		try {
+			return await handle(sessionConnection);
+		} finally {
+			await sessionConnection.close();
+		}
+	};
+	return connection;
 };
 
-// src/storage/sqlite/d1/pool/d1ConnectionPool.ts
-var d1Pool = (options) => createSingletonConnectionPool({
-  driverType: D1DriverType,
-  getConnection: () => d1Connection({
-    ...options,
-    serializer: JSONSerializer.from(options)
-  })
+//#endregion
+//#region src/storage/sqlite/d1/pool/d1ConnectionPool.ts
+const d1Pool = (options) => createSingletonConnectionPool({
+	driverType: D1DriverType,
+	getConnection: () => d1Connection({
+		...options,
+		serializer: JSONSerializer.from(options)
+	})
 });
 
-// src/storage/sqlite/d1/index.ts
-var d1DumboDriver = {
-  driverType: D1DriverType,
-  createPool: (options) => d1Pool(options),
-  sqlFormatter: sqliteFormatter,
-  defaultMigratorOptions: DefaultSQLiteMigratorOptions,
-  canHandle: (options) => {
-    return options.driverType === D1DriverType && "database" in options;
-  },
-  databaseMetadata: sqliteMetadata
+//#endregion
+//#region src/storage/sqlite/d1/index.ts
+const d1DumboDriver = {
+	driverType: D1DriverType,
+	createPool: (options) => d1Pool(options),
+	sqlFormatter: sqliteFormatter,
+	defaultMigratorOptions: DefaultSQLiteMigratorOptions,
+	canHandle: (options) => {
+		return options.driverType === "SQLite:d1" && "database" in options;
+	},
+	databaseMetadata: sqliteMetadata
 };
-var useD1DumboDriver = () => {
-  dumboDatabaseDriverRegistry.register(D1DriverType, d1DumboDriver);
+const useD1DumboDriver = () => {
+	dumboDatabaseDriverRegistry.register(D1DriverType, d1DumboDriver);
 };
 useD1DumboDriver();
-export {
-  D1DriverType,
-  D1TransactionNotSupportedError,
-  DEFAULT_SQLITE_PRAGMA_OPTIONS,
-  DefaultSQLiteMigratorOptions,
-  InMemorySQLiteDatabase,
-  SQLiteConnectionString,
-  SQLiteDatabaseName,
-  d1Client,
-  d1Connection,
-  d1DumboDriver,
-  d1Pool,
-  d1SQLExecutor,
-  d1Transaction,
-  defaultSQLiteDatabase,
-  isInMemoryDatabase,
-  isSQLiteError,
-  mapD1Error,
-  mapSqliteError,
-  parsePragmasFromConnectionString,
-  sqliteAlwaysNewConnectionPool,
-  sqliteAmbientClientConnection,
-  sqliteAmbientConnectionPool,
-  sqliteClientConnection,
-  sqliteConnection,
-  sqliteExecute,
-  sqliteFormatter,
-  sqliteMetadata,
-  sqlitePool,
-  sqlitePoolClientConnection,
-  sqliteSQLExecutor,
-  sqliteSingletonConnectionPool,
-  sqliteTransaction,
-  tableExists,
-  toSqlitePoolOptions,
-  transactionNestingCounter,
-  useD1DumboDriver
-};
+
+//#endregion
+export { D1DriverType, D1TransactionNotSupportedError, DEFAULT_SQLITE_PRAGMA_OPTIONS, DefaultSQLiteMigratorOptions, InMemorySQLiteDatabase, SQLiteConnectionString, SQLiteDatabaseName, d1Client, d1Connection, d1DumboDriver, d1Pool, d1SQLExecutor, d1Transaction, defaultSQLiteDatabase, isInMemoryDatabase, isSQLiteError, mapD1Error, mapSqliteError, parsePragmasFromConnectionString, sqliteAlwaysNewConnectionPool, sqliteAmbientClientConnection, sqliteAmbientConnectionPool, sqliteClientConnection, sqliteConnection, sqliteExecute, sqliteFormatter, sqliteMetadata, sqlitePool, sqlitePoolClientConnection, sqliteSQLExecutor, sqliteSingletonConnectionPool, sqliteTransaction, tableExists, toSqlitePoolOptions, transactionNestingCounter, useD1DumboDriver };
 //# sourceMappingURL=cloudflare.js.map