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

package/dist/cloudflare.cjs

@@ -1,456 +1,401 @@
-"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-var _chunkJIZGCEPEcjs = require('./chunk-JIZGCEPE.cjs');
-
-
-
-
-var _chunkRQ3KKMTPcjs = require('./chunk-RQ3KKMTP.cjs');
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-var _chunk4MMMEDQ7cjs = require('./chunk-4MMMEDQ7.cjs');
-
-// src/storage/sqlite/d1/connections/d1Client.ts
-var d1Client = (options) => {
-  const { database, session, serializer } = options;
-  const execute = _nullishCoalesce(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 } = _chunkJIZGCEPEcjs.sqliteFormatter.format(sql, { serializer });
-      const stmt = execute.prepare(query);
-      const bound = _optionalChain([params, 'optionalAccess', _ => _.length]) ? stmt.bind(...params) : stmt;
-      const { results } = await bound.all();
-      return { rowCount: _nullishCoalesce(_optionalChain([results, 'optionalAccess', _2 => _2.length]), () => ( 0)), rows: _nullishCoalesce(results, () => ( [])) };
-    },
-    batchQuery: async (sqls, _options) => {
-      const statements = sqls.map((sql) => {
-        const { query, params } = _chunkJIZGCEPEcjs.sqliteFormatter.format(sql, { serializer });
-        const stmt = execute.prepare(query);
-        return _optionalChain([params, 'optionalAccess', _3 => _3.length]) ? stmt.bind(...params) : stmt;
-      });
-      const results = await execute.batch(statements);
-      return results.map((result) => ({
-        rowCount: _nullishCoalesce(_optionalChain([result, 'access', _4 => _4.results, 'optionalAccess', _5 => _5.length]), () => ( 0)),
-        rows: _nullishCoalesce(result.results, () => ( []))
-      }));
-    },
-    command: async (sql, _options) => {
-      const { query, params } = _chunkJIZGCEPEcjs.sqliteFormatter.format(sql, { serializer });
-      const stmt = execute.prepare(query);
-      const bound = _optionalChain([params, 'optionalAccess', _6 => _6.length]) ? stmt.bind(...params) : stmt;
-      const result = await bound.run();
-      return {
-        rowCount: _nullishCoalesce(_optionalChain([result, 'access', _7 => _7.meta, 'optionalAccess', _8 => _8.changes]), () => ( 0)),
-        rows: _nullishCoalesce(result.results, () => ( []))
-      };
-    },
-    batchCommand: async (sqls, options2) => {
-      const statements = sqls.map((sql) => {
-        const { query, params } = _chunkJIZGCEPEcjs.sqliteFormatter.format(sql, { serializer });
-        const stmt = execute.prepare(query);
-        return _optionalChain([params, 'optionalAccess', _9 => _9.length]) ? stmt.bind(...params) : stmt;
-      });
-      const batchResults = await execute.batch(statements);
-      return batchResults.map((result, i) => {
-        const qr = {
-          rowCount: _nullishCoalesce(_optionalChain([result, 'access', _10 => _10.meta, 'optionalAccess', _11 => _11.changes]), () => ( 0)),
-          rows: _nullishCoalesce(result.results, () => ( []))
-        };
-        if (_optionalChain([options2, 'optionalAccess', _12 => _12.assertChanges]) && (_nullishCoalesce(qr.rowCount, () => ( 0))) === 0) {
-          throw new (0, _chunk4MMMEDQ7cjs.BatchCommandNoChangesError)(i);
-        }
-        return qr;
-      });
-    }
-  };
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+const require_core = require('./core-BgYtAxCm.cjs');
+const require_sqliteMetadata = require('./sqliteMetadata-D_2pKeCC.cjs');
+const require_core$1 = require('./core-DmbB4qMn.cjs');
+
+//#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 } = require_core$1.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 } = require_core$1.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 } = require_core$1.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 } = require_core$1.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 require_core.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 = _nullishCoalesce(_optionalChain([message, 'optionalAccess', _13 => _13.toUpperCase, 'call', _14 => _14()]), () => ( ""));
-  if (upperMessage.includes("UNIQUE") || upperMessage.includes("PRIMARY KEY"))
-    return new (0, _chunk4MMMEDQ7cjs.UniqueConstraintError)(message, innerError);
-  if (upperMessage.includes("FOREIGN KEY"))
-    return new (0, _chunk4MMMEDQ7cjs.ForeignKeyViolationError)(message, innerError);
-  if (upperMessage.includes("NOT NULL"))
-    return new (0, _chunk4MMMEDQ7cjs.NotNullViolationError)(message, innerError);
-  if (upperMessage.includes("CHECK"))
-    return new (0, _chunk4MMMEDQ7cjs.CheckViolationError)(message, innerError);
-  return new (0, _chunk4MMMEDQ7cjs.IntegrityConstraintViolationError)(message, innerError);
+//#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 require_core.UniqueConstraintError(message, innerError);
+	if (upperMessage.includes("FOREIGN KEY")) return new require_core.ForeignKeyViolationError(message, innerError);
+	if (upperMessage.includes("NOT NULL")) return new require_core.NotNullViolationError(message, innerError);
+	if (upperMessage.includes("CHECK")) return new require_core.CheckViolationError(message, innerError);
+	return new require_core.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 (0, _chunk4MMMEDQ7cjs.LockNotAvailableError)(message, innerError);
-    case "SQLITE_LOCKED":
-      return new (0, _chunk4MMMEDQ7cjs.DeadlockError)(message, innerError);
-    case "SQLITE_PROTOCOL":
-      return new (0, _chunk4MMMEDQ7cjs.LockNotAvailableError)(message, innerError);
-    case "SQLITE_CANTOPEN":
-      return new (0, _chunk4MMMEDQ7cjs.ConnectionError)(message, innerError);
-    case "SQLITE_NOTADB":
-      return new (0, _chunk4MMMEDQ7cjs.ConnectionError)(message, innerError);
-    case "SQLITE_NOMEM":
-      return new (0, _chunk4MMMEDQ7cjs.InsufficientResourcesError)(message, innerError);
-    case "SQLITE_FULL":
-      return new (0, _chunk4MMMEDQ7cjs.InsufficientResourcesError)(message, innerError);
-    case "SQLITE_IOERR":
-      return new (0, _chunk4MMMEDQ7cjs.SystemError)(message, innerError);
-    case "SQLITE_CORRUPT":
-      return new (0, _chunk4MMMEDQ7cjs.SystemError)(message, innerError);
-    case "SQLITE_INTERNAL":
-      return new (0, _chunk4MMMEDQ7cjs.SystemError)(message, innerError);
-    case "SQLITE_NOLFS":
-      return new (0, _chunk4MMMEDQ7cjs.SystemError)(message, innerError);
-    case "SQLITE_TOOBIG":
-      return new (0, _chunk4MMMEDQ7cjs.DataError)(message, innerError);
-    case "SQLITE_MISMATCH":
-      return new (0, _chunk4MMMEDQ7cjs.DataError)(message, innerError);
-    case "SQLITE_RANGE":
-      return new (0, _chunk4MMMEDQ7cjs.DataError)(message, innerError);
-    case "SQLITE_ERROR":
-      return new (0, _chunk4MMMEDQ7cjs.InvalidOperationError)(message, innerError);
-    case "SQLITE_READONLY":
-      return new (0, _chunk4MMMEDQ7cjs.InvalidOperationError)(message, innerError);
-    case "SQLITE_MISUSE":
-      return new (0, _chunk4MMMEDQ7cjs.InvalidOperationError)(message, innerError);
-    case "SQLITE_AUTH":
-      return new (0, _chunk4MMMEDQ7cjs.InvalidOperationError)(message, innerError);
-    case "SQLITE_PERM":
-      return new (0, _chunk4MMMEDQ7cjs.InvalidOperationError)(message, innerError);
-    case "SQLITE_SCHEMA":
-      return new (0, _chunk4MMMEDQ7cjs.InvalidOperationError)(message, innerError);
-    case "SQLITE_ABORT":
-      return new (0, _chunk4MMMEDQ7cjs.SerializationError)(message, innerError);
-    case "SQLITE_INTERRUPT":
-      return new (0, _chunk4MMMEDQ7cjs.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 require_core.LockNotAvailableError(message, innerError);
+		case "SQLITE_LOCKED": return new require_core.DeadlockError(message, innerError);
+		case "SQLITE_PROTOCOL": return new require_core.LockNotAvailableError(message, innerError);
+		case "SQLITE_CANTOPEN": return new require_core.ConnectionError(message, innerError);
+		case "SQLITE_NOTADB": return new require_core.ConnectionError(message, innerError);
+		case "SQLITE_NOMEM": return new require_core.InsufficientResourcesError(message, innerError);
+		case "SQLITE_FULL": return new require_core.InsufficientResourcesError(message, innerError);
+		case "SQLITE_IOERR": return new require_core.SystemError(message, innerError);
+		case "SQLITE_CORRUPT": return new require_core.SystemError(message, innerError);
+		case "SQLITE_INTERNAL": return new require_core.SystemError(message, innerError);
+		case "SQLITE_NOLFS": return new require_core.SystemError(message, innerError);
+		case "SQLITE_TOOBIG": return new require_core.DataError(message, innerError);
+		case "SQLITE_MISMATCH": return new require_core.DataError(message, innerError);
+		case "SQLITE_RANGE": return new require_core.DataError(message, innerError);
+		case "SQLITE_ERROR": return new require_core.InvalidOperationError(message, innerError);
+		case "SQLITE_READONLY": return new require_core.InvalidOperationError(message, innerError);
+		case "SQLITE_MISUSE": return new require_core.InvalidOperationError(message, innerError);
+		case "SQLITE_AUTH": return new require_core.InvalidOperationError(message, innerError);
+		case "SQLITE_PERM": return new require_core.InvalidOperationError(message, innerError);
+		case "SQLITE_SCHEMA": return new require_core.InvalidOperationError(message, innerError);
+		case "SQLITE_ABORT": return new require_core.SerializationError(message, innerError);
+		case "SQLITE_INTERRUPT": return new require_core.SerializationError(message, innerError);
+	}
 };
-var mapD1Error = (error) => {
-  if (_chunk4MMMEDQ7cjs.DumboError.isInstanceOf(error)) return error;
-  const message = getErrorMessage(error);
-  if (!message)
-    return new (0, _chunk4MMMEDQ7cjs.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 (0, _chunk4MMMEDQ7cjs.DataError)(message, innerError);
-  if (upper.startsWith("D1_COLUMN_NOTFOUND"))
-    return new (0, _chunk4MMMEDQ7cjs.DataError)(message, innerError);
-  if (upper.startsWith("D1_DUMP_ERROR"))
-    return new (0, _chunk4MMMEDQ7cjs.SystemError)(message, innerError);
-  if (upper.startsWith("D1_SESSION_ERROR"))
-    return new (0, _chunk4MMMEDQ7cjs.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 (0, _chunk4MMMEDQ7cjs.ConnectionError)(message, innerError);
-  if (upper.includes("D1 DB IS OVERLOADED") || upper.includes("TOO MANY REQUESTS") || upper.includes("MEMORY LIMIT WOULD BE EXCEEDED"))
-    return new (0, _chunk4MMMEDQ7cjs.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 (0, _chunk4MMMEDQ7cjs.InvalidOperationError)(message, innerError);
-  }
-  const embeddedCode = extractEmbeddedSqliteCode(message);
-  if (embeddedCode) {
-    const mapped = mapEmbeddedSqliteCode(embeddedCode, message, innerError);
-    if (mapped) return mapped;
-  }
-  return new (0, _chunk4MMMEDQ7cjs.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 (require_core.DumboError.isInstanceOf(error)) return error;
+	const message = getErrorMessage(error);
+	if (!message) return new require_core.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 require_core.DataError(message, innerError);
+	if (upper.startsWith("D1_COLUMN_NOTFOUND")) return new require_core.DataError(message, innerError);
+	if (upper.startsWith("D1_DUMP_ERROR")) return new require_core.SystemError(message, innerError);
+	if (upper.startsWith("D1_SESSION_ERROR")) return new require_core.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 require_core.ConnectionError(message, innerError);
+	if (upper.includes("D1 DB IS OVERLOADED") || upper.includes("TOO MANY REQUESTS") || upper.includes("MEMORY LIMIT WOULD BE EXCEEDED")) return new require_core.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 require_core.InvalidOperationError(message, innerError);
+	}
+	const embeddedCode = extractEmbeddedSqliteCode(message);
+	if (embeddedCode) {
+		const mapped = mapEmbeddedSqliteCode(embeddedCode, message, innerError);
+		if (mapped) return mapped;
+	}
+	return new require_core.DumboError({
+		errorCode: 500,
+		message,
+		innerError
+	});
 };
 
-// src/storage/sqlite/d1/execute/d1SqlExecutor.ts
-var d1SQLExecutor = () => ({
-  driverType: "SQLite:d1",
-  formatter: _chunkJIZGCEPEcjs.sqliteFormatter,
-  query: async (client, sql, options) => {
-    try {
-      return await client.query(sql, options);
-    } catch (error) {
-      _chunk4MMMEDQ7cjs.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) {
-      _chunk4MMMEDQ7cjs.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) {
-      _chunk4MMMEDQ7cjs.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) {
-      _chunk4MMMEDQ7cjs.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: require_core$1.sqliteFormatter,
+	query: async (client, sql, options) => {
+		try {
+			return await client.query(sql, options);
+		} catch (error) {
+			require_core.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) {
+			require_core.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) {
+			require_core.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) {
+			require_core.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 = _chunkJIZGCEPEcjs.transactionNestingCounter.call(void 0, );
-  const allowNestedTransactions = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _15 => _15.allowNestedTransactions]), () => ( _optionalChain([defaultOptions, 'optionalAccess', _16 => _16.allowNestedTransactions])));
-  const mode = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _17 => _17.mode]), () => ( _optionalChain([defaultOptions, 'optionalAccess', _18 => _18.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(_optionalChain([options, 'optionalAccess', _19 => _19.d1Session]));
-    },
-    commit: async function() {
-      const client2 = await getDatabaseClient();
-      try {
-        if (allowNestedTransactions) {
-          if (transactionCounter.level > 1) {
-            transactionCounter.decrement();
-            return;
-          }
-          transactionCounter.reset();
-        }
-        sessionClient = null;
-      } finally {
-        if (_optionalChain([options, 'optionalAccess', _20 => _20.close])) await _optionalChain([options, 'optionalAccess', _21 => _21.close, 'call', _22 => _22(client2)]);
-      }
-    },
-    rollback: async function(error) {
-      const client2 = await getDatabaseClient();
-      try {
-        if (allowNestedTransactions) {
-          if (transactionCounter.level > 1) {
-            transactionCounter.decrement();
-            return;
-          }
-        }
-        sessionClient = null;
-      } finally {
-        if (_optionalChain([options, 'optionalAccess', _23 => _23.close])) await _optionalChain([options, 'optionalAccess', _24 => _24.close, 'call', _25 => _25(client2, error)]);
-      }
-    },
-    execute: _chunk4MMMEDQ7cjs.sqlExecutor.call(void 0, d1SQLExecutor(), {
-      connect: () => {
-        if (!sessionClient) {
-          throw new Error(
-            "Transaction has not been started. Call begin() first."
-          );
-        }
-        return Promise.resolve(sessionClient);
-      }
-    }),
-    _transactionOptions: _nullishCoalesce(options, () => ( {}))
-  };
+const d1Transaction = (connection, serializer, defaultOptions) => (getClient, options) => {
+	const transactionCounter = require_core$1.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: require_core.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 = _nullishCoalesce(_nullishCoalesce(options.connection, () => ( _optionalChain([options, 'access', _26 => _26.transaction, 'optionalAccess', _27 => _27.connection]))), () => ( {
-    ..._chunkJIZGCEPEcjs.sqliteAmbientClientConnection.call(void 0, {
-      driverType: D1DriverType,
-      client: _nullishCoalesce(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 ?? { ...require_core$1.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) => _chunk4MMMEDQ7cjs.createSingletonConnectionPool.call(void 0, {
-  driverType: D1DriverType,
-  getConnection: () => d1Connection({
-    ...options,
-    serializer: _chunk4MMMEDQ7cjs.JSONSerializer.from(options)
-  })
+//#endregion
+//#region src/storage/sqlite/d1/pool/d1ConnectionPool.ts
+const d1Pool = (options) => require_core.createSingletonConnectionPool({
+	driverType: D1DriverType,
+	getConnection: () => d1Connection({
+		...options,
+		serializer: require_core.JSONSerializer.from(options)
+	})
 });
 
-// src/storage/sqlite/d1/index.ts
-var d1DumboDriver = {
-  driverType: D1DriverType,
-  createPool: (options) => d1Pool(options),
-  sqlFormatter: _chunkJIZGCEPEcjs.sqliteFormatter,
-  defaultMigratorOptions: _chunkJIZGCEPEcjs.DefaultSQLiteMigratorOptions,
-  canHandle: (options) => {
-    return options.driverType === D1DriverType && "database" in options;
-  },
-  databaseMetadata: _chunkRQ3KKMTPcjs.sqliteMetadata
+//#endregion
+//#region src/storage/sqlite/d1/index.ts
+const d1DumboDriver = {
+	driverType: D1DriverType,
+	createPool: (options) => d1Pool(options),
+	sqlFormatter: require_core$1.sqliteFormatter,
+	defaultMigratorOptions: require_core$1.DefaultSQLiteMigratorOptions,
+	canHandle: (options) => {
+		return options.driverType === "SQLite:d1" && "database" in options;
+	},
+	databaseMetadata: require_sqliteMetadata.sqliteMetadata
 };
-var useD1DumboDriver = () => {
-  _chunk4MMMEDQ7cjs.dumboDatabaseDriverRegistry.register(D1DriverType, d1DumboDriver);
+const useD1DumboDriver = () => {
+	require_core.dumboDatabaseDriverRegistry.register(D1DriverType, d1DumboDriver);
 };
 useD1DumboDriver();
 
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-exports.D1DriverType = D1DriverType; exports.D1TransactionNotSupportedError = D1TransactionNotSupportedError; exports.DEFAULT_SQLITE_PRAGMA_OPTIONS = _chunkJIZGCEPEcjs.DEFAULT_SQLITE_PRAGMA_OPTIONS; exports.DefaultSQLiteMigratorOptions = _chunkJIZGCEPEcjs.DefaultSQLiteMigratorOptions; exports.InMemorySQLiteDatabase = _chunkJIZGCEPEcjs.InMemorySQLiteDatabase; exports.SQLiteConnectionString = _chunkJIZGCEPEcjs.SQLiteConnectionString; exports.SQLiteDatabaseName = _chunkJIZGCEPEcjs.SQLiteDatabaseName; exports.d1Client = d1Client; exports.d1Connection = d1Connection; exports.d1DumboDriver = d1DumboDriver; exports.d1Pool = d1Pool; exports.d1SQLExecutor = d1SQLExecutor; exports.d1Transaction = d1Transaction; exports.defaultSQLiteDatabase = _chunkRQ3KKMTPcjs.defaultSQLiteDatabase; exports.isInMemoryDatabase = _chunkJIZGCEPEcjs.isInMemoryDatabase; exports.isSQLiteError = _chunkJIZGCEPEcjs.isSQLiteError; exports.mapD1Error = mapD1Error; exports.mapSqliteError = _chunkJIZGCEPEcjs.mapSqliteError; exports.parsePragmasFromConnectionString = _chunkJIZGCEPEcjs.parsePragmasFromConnectionString; exports.sqliteAlwaysNewConnectionPool = _chunkJIZGCEPEcjs.sqliteAlwaysNewConnectionPool; exports.sqliteAmbientClientConnection = _chunkJIZGCEPEcjs.sqliteAmbientClientConnection; exports.sqliteAmbientConnectionPool = _chunkJIZGCEPEcjs.sqliteAmbientConnectionPool; exports.sqliteClientConnection = _chunkJIZGCEPEcjs.sqliteClientConnection; exports.sqliteConnection = _chunkJIZGCEPEcjs.sqliteConnection; exports.sqliteExecute = _chunkJIZGCEPEcjs.sqliteExecute; exports.sqliteFormatter = _chunkJIZGCEPEcjs.sqliteFormatter; exports.sqliteMetadata = _chunkRQ3KKMTPcjs.sqliteMetadata; exports.sqlitePool = _chunkJIZGCEPEcjs.sqlitePool; exports.sqlitePoolClientConnection = _chunkJIZGCEPEcjs.sqlitePoolClientConnection; exports.sqliteSQLExecutor = _chunkJIZGCEPEcjs.sqliteSQLExecutor; exports.sqliteSingletonConnectionPool = _chunkJIZGCEPEcjs.sqliteSingletonConnectionPool; exports.sqliteTransaction = _chunkJIZGCEPEcjs.sqliteTransaction; exports.tableExists = _chunkRQ3KKMTPcjs.tableExists; exports.toSqlitePoolOptions = _chunkJIZGCEPEcjs.toSqlitePoolOptions; exports.transactionNestingCounter = _chunkJIZGCEPEcjs.transactionNestingCounter; exports.useD1DumboDriver = useD1DumboDriver;
+//#endregion
+exports.D1DriverType = D1DriverType;
+exports.D1TransactionNotSupportedError = D1TransactionNotSupportedError;
+exports.DEFAULT_SQLITE_PRAGMA_OPTIONS = require_core$1.DEFAULT_SQLITE_PRAGMA_OPTIONS;
+exports.DefaultSQLiteMigratorOptions = require_core$1.DefaultSQLiteMigratorOptions;
+exports.InMemorySQLiteDatabase = require_core$1.InMemorySQLiteDatabase;
+exports.SQLiteConnectionString = require_core$1.SQLiteConnectionString;
+exports.SQLiteDatabaseName = require_core$1.SQLiteDatabaseName;
+exports.d1Client = d1Client;
+exports.d1Connection = d1Connection;
+exports.d1DumboDriver = d1DumboDriver;
+exports.d1Pool = d1Pool;
+exports.d1SQLExecutor = d1SQLExecutor;
+exports.d1Transaction = d1Transaction;
+exports.defaultSQLiteDatabase = require_sqliteMetadata.defaultSQLiteDatabase;
+exports.isInMemoryDatabase = require_core$1.isInMemoryDatabase;
+exports.isSQLiteError = require_core$1.isSQLiteError;
+exports.mapD1Error = mapD1Error;
+exports.mapSqliteError = require_core$1.mapSqliteError;
+exports.parsePragmasFromConnectionString = require_core$1.parsePragmasFromConnectionString;
+exports.sqliteAlwaysNewConnectionPool = require_core$1.sqliteAlwaysNewConnectionPool;
+exports.sqliteAmbientClientConnection = require_core$1.sqliteAmbientClientConnection;
+exports.sqliteAmbientConnectionPool = require_core$1.sqliteAmbientConnectionPool;
+exports.sqliteClientConnection = require_core$1.sqliteClientConnection;
+exports.sqliteConnection = require_core$1.sqliteConnection;
+exports.sqliteExecute = require_core$1.sqliteExecute;
+exports.sqliteFormatter = require_core$1.sqliteFormatter;
+exports.sqliteMetadata = require_sqliteMetadata.sqliteMetadata;
+exports.sqlitePool = require_core$1.sqlitePool;
+exports.sqlitePoolClientConnection = require_core$1.sqlitePoolClientConnection;
+exports.sqliteSQLExecutor = require_core$1.sqliteSQLExecutor;
+exports.sqliteSingletonConnectionPool = require_core$1.sqliteSingletonConnectionPool;
+exports.sqliteTransaction = require_core$1.sqliteTransaction;
+exports.tableExists = require_sqliteMetadata.tableExists;
+exports.toSqlitePoolOptions = require_core$1.toSqlitePoolOptions;
+exports.transactionNestingCounter = require_core$1.transactionNestingCounter;
+exports.useD1DumboDriver = useD1DumboDriver;
 //# sourceMappingURL=cloudflare.cjs.map