@hot-updater/server 1.0.0-rc.1 → 1.0.0-rc.16

package/dist/adapters/kysely.mjs

@@ -1,36 +1,30 @@
-import { createKyselyMigrator } from "../db/fixedMigrator.mjs";
-import { createKyselyCrud } from "./kyselyCrud.mjs";
-import { createDatabasePlugin } from "@hot-updater/plugin-core";
-import { createDatabasePluginAdapter } from "@hot-updater/plugin-core/internal";
+import { builtInTarget, createEngineDatabase } from "../db/builtInDatabase.mjs";
+import { createSqlAdapter } from "../database/sql/sqlAdapter.mjs";
+import { createEngineSqlMigrator } from "../db/engineSqlMigrator.mjs";
+import { kyselyExecutor } from "./kyselyExecutor.mjs";
+import { checkSqlProvider } from "./sqlProviders.mjs";
 //#region src/adapters/kysely.ts
-const createImplementation = (config) => {
-	const db = config.db;
-	const relationMode = config.relationMode ?? "foreign-keys";
-	return {
-		...createKyselyCrud(db, config.provider, relationMode),
-		deleteChannel: (input) => db.transaction().execute((transaction) => createKyselyCrud(transaction, config.provider, relationMode).deleteChannel(input)),
-		create: (input) => db.transaction().execute((transaction) => createKyselyCrud(transaction, config.provider, relationMode).create(input)),
-		update: (input) => db.transaction().execute((transaction) => createKyselyCrud(transaction, config.provider, relationMode).update(input)),
-		delete: (input) => db.transaction().execute((transaction) => createKyselyCrud(transaction, config.provider, relationMode).delete(input)),
-		transaction: (callback) => db.transaction().execute((transaction) => callback(createKyselyCrud(transaction, config.provider, relationMode)))
-	};
-};
+/**
+* Hot Updater's database on a Kysely instance: the storage engine through the
+* shared SQL core, fenced by the schema settings. `db migrate` and
+* `db generate --sql` apply the engine's SQL schema.
+*/
 const kyselyAdapter = (config) => {
-	const adapter = createDatabasePluginAdapter("kysely", createImplementation(config));
-	const plugin = createDatabasePlugin({
-		name: "kysely",
-		models: adapter.models,
-		commit: adapter.commit
-	});
-	return Object.assign(plugin, {
-		adapterName: "kysely",
-		provider: config.provider,
-		createMigrator: () => createKyselyMigrator({
-			db: config.db,
-			provider: config.provider,
-			relationMode: config.relationMode
+	const provider = checkSqlProvider("kyselyAdapter", config.provider);
+	const executor = kyselyExecutor(config.db, provider);
+	return {
+		...createEngineDatabase({
+			name: "kysely",
+			adapter: createSqlAdapter({ executor })
+		}),
+		provider,
+		createMigrator: ({ schema, settings } = builtInTarget) => createEngineSqlMigrator({
+			adapterName: "kysely",
+			executor,
+			schema,
+			settings
 		})
-	});
+	};
 };
 //#endregion
-export { kyselyAdapter };
+export { kyselyAdapter, kyselyExecutor };

package/dist/adapters/kyselyExecutor.cjs

@@ -0,0 +1,32 @@
+let kysely = require("kysely");
+//#region src/adapters/kyselyExecutor.ts
+const over = (runner) => ({ async execute({ sql, params }) {
+	const result = await runner.executeQuery(kysely.CompiledQuery.raw(sql, [...params]));
+	return {
+		rows: result.rows,
+		changes: Number(result.numAffectedRows ?? 0n)
+	};
+} });
+const raw = (runner, sql) => runner.executeQuery(kysely.CompiledQuery.raw(sql));
+/**
+* The SQL core's executor over a Kysely instance: statements run as raw
+* compiled queries. SQLite transactions begin with BEGIN IMMEDIATE on one
+* connection; other dialects use Kysely's transactions.
+*/
+const kyselyExecutor = (db, dialect) => ({
+	dialect,
+	...over(db),
+	transaction: (fn) => dialect === "sqlite" ? db.connection().execute(async (connection) => {
+		await raw(connection, "BEGIN IMMEDIATE");
+		try {
+			const result = await fn(over(connection));
+			await raw(connection, "COMMIT");
+			return result;
+		} catch (error) {
+			await raw(connection, "ROLLBACK").catch(() => void 0);
+			throw error;
+		}
+	}) : db.transaction().execute((transaction) => fn(over(transaction)))
+});
+//#endregion
+exports.kyselyExecutor = kyselyExecutor;

package/dist/adapters/kyselyExecutor.d.cts

@@ -0,0 +1,12 @@
+import { SqlDialect } from "../database/sql/sqlSchema.cjs";
+import { SqlExecutor } from "../database/sql/sqlAdapter.cjs";
+import { Kysely } from "kysely";
+//#region src/adapters/kyselyExecutor.d.ts
+/**
+ * The SQL core's executor over a Kysely instance: statements run as raw
+ * compiled queries. SQLite transactions begin with BEGIN IMMEDIATE on one
+ * connection; other dialects use Kysely's transactions.
+ */
+declare const kyselyExecutor: (db: Kysely<object>, dialect: SqlDialect) => SqlExecutor;
+//#endregion
+export { kyselyExecutor };

package/dist/adapters/kyselyExecutor.d.mts

@@ -0,0 +1,12 @@
+import { SqlDialect } from "../database/sql/sqlSchema.mjs";
+import { SqlExecutor } from "../database/sql/sqlAdapter.mjs";
+import { Kysely } from "kysely";
+//#region src/adapters/kyselyExecutor.d.ts
+/**
+ * The SQL core's executor over a Kysely instance: statements run as raw
+ * compiled queries. SQLite transactions begin with BEGIN IMMEDIATE on one
+ * connection; other dialects use Kysely's transactions.
+ */
+declare const kyselyExecutor: (db: Kysely<object>, dialect: SqlDialect) => SqlExecutor;
+//#endregion
+export { kyselyExecutor };

package/dist/adapters/kyselyExecutor.mjs

@@ -0,0 +1,32 @@
+import { CompiledQuery } from "kysely";
+//#region src/adapters/kyselyExecutor.ts
+const over = (runner) => ({ async execute({ sql, params }) {
+	const result = await runner.executeQuery(CompiledQuery.raw(sql, [...params]));
+	return {
+		rows: result.rows,
+		changes: Number(result.numAffectedRows ?? 0n)
+	};
+} });
+const raw = (runner, sql) => runner.executeQuery(CompiledQuery.raw(sql));
+/**
+* The SQL core's executor over a Kysely instance: statements run as raw
+* compiled queries. SQLite transactions begin with BEGIN IMMEDIATE on one
+* connection; other dialects use Kysely's transactions.
+*/
+const kyselyExecutor = (db, dialect) => ({
+	dialect,
+	...over(db),
+	transaction: (fn) => dialect === "sqlite" ? db.connection().execute(async (connection) => {
+		await raw(connection, "BEGIN IMMEDIATE");
+		try {
+			const result = await fn(over(connection));
+			await raw(connection, "COMMIT");
+			return result;
+		} catch (error) {
+			await raw(connection, "ROLLBACK").catch(() => void 0);
+			throw error;
+		}
+	}) : db.transaction().execute((transaction) => fn(over(transaction)))
+});
+//#endregion
+export { kyselyExecutor };

package/dist/adapters/mongodb.cjs

@@ -1,35 +1,36 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-require("../_virtual/_rolldown/runtime.cjs");
-const require_fixedMigratorMongo = require("../db/fixedMigratorMongo.cjs");
-const require_mongodbCollections = require("./mongodbCollections.cjs");
-const require_mongodbReads = require("./mongodbReads.cjs");
-const require_mongodbWrites = require("./mongodbWrites.cjs");
-let _hot_updater_plugin_core = require("@hot-updater/plugin-core");
-let _hot_updater_plugin_core_internal = require("@hot-updater/plugin-core/internal");
+const require_fence = require("../database/fence.cjs");
+const require_engineMigrator = require("../db/engineMigrator.cjs");
+const require_builtInDatabase = require("../db/builtInDatabase.cjs");
+const require_mongodbAdapter = require("./mongodbAdapter.cjs");
 //#region src/adapters/mongodb.ts
-const createMongoImplementation = (client, session) => {
-	const collections = require_mongodbCollections.createMongoCollections(client);
-	return {
-		...require_mongodbWrites.createMongoWrites(collections, session),
-		...require_mongodbReads.createMongoReads(collections, session)
-	};
+/** Settings rows by their `key` field: the engine's rows and a v0 database's alike. */
+const readSettings = (client) => async () => {
+	const rows = await client.db().collection(require_fence.SETTINGS_TABLE.name).find({ key: { $type: "string" } }).toArray();
+	return new Map(rows.map((row) => [String(row.key), row.value]));
 };
-const createTransactionalMongoImplementation = (client) => ({
-	...createMongoImplementation(client),
-	deleteChannel: (input) => client.withSession((session) => session.withTransaction(() => createMongoImplementation(client, session).deleteChannel(input))),
-	transaction: (callback) => client.withSession((session) => session.withTransaction(() => callback(createMongoImplementation(client, session))))
-});
+/**
+* Hot Updater's database on MongoDB: the storage engine's MongoDB adapter,
+* fenced by the schema settings. `db migrate` creates the collections and
+* indexes, then writes the settings.
+*/
 const mongoAdapter = (config) => {
-	const adapter = (0, _hot_updater_plugin_core_internal.createDatabasePluginAdapter)("mongodb", config.transactions === true ? createTransactionalMongoImplementation(config.client) : createMongoImplementation(config.client));
-	return Object.assign((0, _hot_updater_plugin_core.createDatabasePlugin)({
-		name: "mongodb",
-		models: adapter.models,
-		commit: adapter.commit
-	}), {
-		adapterName: "mongodb",
+	const adapter = require_mongodbAdapter.createMongoAdapter({ client: config.client });
+	return {
+		...require_builtInDatabase.createEngineDatabase({
+			name: "mongodb",
+			adapter
+		}),
 		provider: "mongodb",
-		createMigrator: () => require_fixedMigratorMongo.createMongoMigrator(config.client)
-	});
+		createMigrator: ({ schema, settings } = require_builtInDatabase.builtInTarget) => require_engineMigrator.createEngineMigrator({
+			adapterName: "mongodb",
+			adapter,
+			schema,
+			settings,
+			readSettings: readSettings(config.client)
+		})
+	};
 };
 //#endregion
+exports.MongoTransactionUnsupportedError = require_mongodbAdapter.MongoTransactionUnsupportedError;
 exports.mongoAdapter = mongoAdapter;

package/dist/adapters/mongodb.d.cts

@@ -1,11 +1,16 @@
-import { DatabaseAdapterWithCapabilities } from "../db/types.cjs";
+import { ToolingDatabase } from "../db/types.cjs";
+import { MongoTransactionUnsupportedError } from "./mongodbAdapter.cjs";
 import { MongoClient } from "mongodb";
-
 //#region src/adapters/mongodb.d.ts
+/** Every write runs in a transaction, which needs a replica set or a sharded cluster. */
 interface MongoDBConfig {
   readonly client: MongoClient;
-  readonly transactions?: boolean;
 }
-declare const mongoAdapter: (config: MongoDBConfig) => DatabaseAdapterWithCapabilities;
+/**
+ * Hot Updater's database on MongoDB: the storage engine's MongoDB adapter,
+ * fenced by the schema settings. `db migrate` creates the collections and
+ * indexes, then writes the settings.
+ */
+declare const mongoAdapter: (config: MongoDBConfig) => ToolingDatabase;
 //#endregion
-export { MongoDBConfig, mongoAdapter };
+export { MongoDBConfig, MongoTransactionUnsupportedError, mongoAdapter };

package/dist/adapters/mongodb.d.mts

@@ -1,11 +1,16 @@
-import { DatabaseAdapterWithCapabilities } from "../db/types.mjs";
+import { ToolingDatabase } from "../db/types.mjs";
+import { MongoTransactionUnsupportedError } from "./mongodbAdapter.mjs";
 import { MongoClient } from "mongodb";
-
 //#region src/adapters/mongodb.d.ts
+/** Every write runs in a transaction, which needs a replica set or a sharded cluster. */
 interface MongoDBConfig {
   readonly client: MongoClient;
-  readonly transactions?: boolean;
 }
-declare const mongoAdapter: (config: MongoDBConfig) => DatabaseAdapterWithCapabilities;
+/**
+ * Hot Updater's database on MongoDB: the storage engine's MongoDB adapter,
+ * fenced by the schema settings. `db migrate` creates the collections and
+ * indexes, then writes the settings.
+ */
+declare const mongoAdapter: (config: MongoDBConfig) => ToolingDatabase;
 //#endregion
-export { MongoDBConfig, mongoAdapter };
+export { MongoDBConfig, MongoTransactionUnsupportedError, mongoAdapter };

package/dist/adapters/mongodb.mjs

@@ -1,33 +1,34 @@
-import { createMongoMigrator } from "../db/fixedMigratorMongo.mjs";
-import { createMongoCollections } from "./mongodbCollections.mjs";
-import { createMongoReads } from "./mongodbReads.mjs";
-import { createMongoWrites } from "./mongodbWrites.mjs";
-import { createDatabasePlugin } from "@hot-updater/plugin-core";
-import { createDatabasePluginAdapter } from "@hot-updater/plugin-core/internal";
+import { SETTINGS_TABLE } from "../database/fence.mjs";
+import { createEngineMigrator } from "../db/engineMigrator.mjs";
+import { builtInTarget, createEngineDatabase } from "../db/builtInDatabase.mjs";
+import { MongoTransactionUnsupportedError, createMongoAdapter } from "./mongodbAdapter.mjs";
 //#region src/adapters/mongodb.ts
-const createMongoImplementation = (client, session) => {
-	const collections = createMongoCollections(client);
-	return {
-		...createMongoWrites(collections, session),
-		...createMongoReads(collections, session)
-	};
+/** Settings rows by their `key` field: the engine's rows and a v0 database's alike. */
+const readSettings = (client) => async () => {
+	const rows = await client.db().collection(SETTINGS_TABLE.name).find({ key: { $type: "string" } }).toArray();
+	return new Map(rows.map((row) => [String(row.key), row.value]));
 };
-const createTransactionalMongoImplementation = (client) => ({
-	...createMongoImplementation(client),
-	deleteChannel: (input) => client.withSession((session) => session.withTransaction(() => createMongoImplementation(client, session).deleteChannel(input))),
-	transaction: (callback) => client.withSession((session) => session.withTransaction(() => callback(createMongoImplementation(client, session))))
-});
+/**
+* Hot Updater's database on MongoDB: the storage engine's MongoDB adapter,
+* fenced by the schema settings. `db migrate` creates the collections and
+* indexes, then writes the settings.
+*/
 const mongoAdapter = (config) => {
-	const adapter = createDatabasePluginAdapter("mongodb", config.transactions === true ? createTransactionalMongoImplementation(config.client) : createMongoImplementation(config.client));
-	return Object.assign(createDatabasePlugin({
-		name: "mongodb",
-		models: adapter.models,
-		commit: adapter.commit
-	}), {
-		adapterName: "mongodb",
+	const adapter = createMongoAdapter({ client: config.client });
+	return {
+		...createEngineDatabase({
+			name: "mongodb",
+			adapter
+		}),
 		provider: "mongodb",
-		createMigrator: () => createMongoMigrator(config.client)
-	});
+		createMigrator: ({ schema, settings } = builtInTarget) => createEngineMigrator({
+			adapterName: "mongodb",
+			adapter,
+			schema,
+			settings,
+			readSettings: readSettings(config.client)
+		})
+	};
 };
 //#endregion
-export { mongoAdapter };
+export { MongoTransactionUnsupportedError, mongoAdapter };

package/dist/adapters/mongodbAdapter.cjs

@@ -0,0 +1,174 @@
+let _hot_updater_plugin_core_internal = require("@hot-updater/plugin-core/internal");
+let mongodb = require("mongodb");
+//#region src/adapters/mongodbAdapter.ts
+var MongoTransactionUnsupportedError = class extends Error {
+	name = "MongoTransactionUnsupportedError";
+	constructor(cause) {
+		super("Hot Updater writes in MongoDB transactions, which need a replica set or a sharded cluster.", { cause });
+	}
+};
+/** A single key column is the `_id`; a composite key is a document in key-column order. */
+const idOf = (table, key) => table.key.length === 1 ? key[0] : Object.fromEntries(table.key.map((column, at) => [column, key[at]]));
+/** A filter on `_id` (never an ObjectId), and on the version when given. */
+const byId = (_id, v) => v === void 0 ? { _id } : {
+	_id,
+	[_hot_updater_plugin_core_internal.DATABASE_VERSION_COLUMN]: v
+};
+/** Null columns are left out, so unique indexes skip them as SQL's do. */
+const toDocument = (table, row) => ({
+	_id: idOf(table, (0, _hot_updater_plugin_core_internal.rowKey)(table, row)),
+	...Object.fromEntries(table.columns.flatMap(({ name }) => row[name] === null || row[name] === void 0 ? [] : [[name, row[name]]]))
+});
+/** `columns op bound` over a tuple prefix, expanded into ORs. */
+const compare = (columns, { values, inclusive }, op) => {
+	const terms = values.map((value, position) => ({
+		...Object.fromEntries(columns.slice(0, position).map((column, at) => [column, values[at]])),
+		[columns[position]]: { [position === values.length - 1 && inclusive ? `${op}e` : op]: value }
+	}));
+	return terms.length === 1 ? terms[0] : { $or: terms };
+};
+const indexDescription = (table, index) => {
+	const columns = index.unique ? index.eq : [...index.eq, ...(0, _hot_updater_plugin_core_internal.indexOrderColumns)(table, index)];
+	const exists = columns.filter((column) => (0, _hot_updater_plugin_core_internal.findPhysicalColumn)(table, column).nullable).map((column) => [column, { $exists: true }]);
+	return {
+		name: index.name,
+		key: Object.fromEntries(columns.map((column) => [column, 1])),
+		...index.unique && { unique: true },
+		...index.unique && exists.length > 0 && { partialFilterExpression: Object.fromEntries(exists) }
+	};
+};
+const mongoError = (error) => error instanceof mongodb.MongoError ? error : void 0;
+/**
+* The storage engine's adapter over MongoDB: one collection per table, the
+* key as `_id`, and indexes as declared, with multi-valued fields as multikey
+* indexes. A write runs in one transaction. Guards are conditional updates,
+* and `check` is a conditional `$inc`: a real write, so a concurrent
+* transaction on the document conflicts.
+*/
+const createMongoAdapter = (options) => {
+	const { client, tablePrefix = "", maxOps = 1e3 } = options;
+	const collection = (table) => client.db().collection(tablePrefix + table.name);
+	const normalize = (table, document) => (0, _hot_updater_plugin_core_internal.normalizeStoredRow)(table, document, { jsonText: false });
+	/** Whether the op applied; a guard that no longer matches changes nothing. */
+	const apply = async (op, session) => {
+		const target = collection(op.table);
+		if (op.type === "insert") {
+			await target.insertOne(toDocument(op.table, op.row), { session });
+			return true;
+		}
+		const _id = idOf(op.table, op.key);
+		const update = async (filter, change) => (await target.updateOne(filter, change, { session })).matchedCount === 1;
+		switch (op.type) {
+			case "patch": {
+				const $set = { [_hot_updater_plugin_core_internal.DATABASE_VERSION_COLUMN]: op.guard.v + 1 };
+				const $unset = {};
+				for (const [name, value] of Object.entries(op.set)) if (value === null) $unset[name] = "";
+				else $set[name] = value;
+				return update(byId(_id, op.guard.v), {
+					$set,
+					$unset
+				});
+			}
+			case "delete": return (await target.deleteOne(byId(_id, op.guard.v), { session })).deletedCount === 1;
+			case "check": return update(byId(_id, op.guard.v), { $inc: { _checked: 1 } });
+			case "increment": {
+				if (op.init === void 0 || op.guard !== void 0) return update(byId(_id, op.guard?.v), { $inc: {
+					...op.by,
+					[_hot_updater_plugin_core_internal.DATABASE_VERSION_COLUMN]: 1
+				} });
+				const set = {};
+				for (const { name } of op.table.columns) {
+					const start = op.init[name] ?? null;
+					const by = name === _hot_updater_plugin_core_internal.DATABASE_VERSION_COLUMN ? 1 : op.by[name];
+					const stored = { $ifNull: [`$${name}`, { $literal: start ?? 0 }] };
+					if (by !== void 0) set[name] = { $add: [stored, by] };
+					else if (start !== null) set[name] = stored;
+				}
+				await target.updateOne(byId(_id), [{ $set: set }], {
+					upsert: true,
+					session
+				});
+				return true;
+			}
+		}
+	};
+	return {
+		id: "mongodb",
+		fits: (ops) => ops.length <= maxOps,
+		async get(table, keys) {
+			if (keys.length === 0) return [];
+			const ids = keys.map((key) => idOf(table, key));
+			const documents = await collection(table).find(byId({ $in: ids })).toArray();
+			const found = new Map(documents.map((document) => [JSON.stringify(document._id), document]));
+			return ids.map((id) => {
+				const document = found.get(JSON.stringify(id));
+				return document === void 0 ? null : normalize(table, document);
+			});
+		},
+		async query(table, request) {
+			const index = (0, _hot_updater_plugin_core_internal.findPhysicalIndex)(table, request.index);
+			const columns = (0, _hot_updater_plugin_core_internal.indexOrderColumns)(table, index);
+			const bounds = [...request.lower ? [compare(columns, request.lower, "$gt")] : [], ...request.upper ? [compare(columns, request.upper, "$lt")] : []];
+			const direction = request.order === "asc" ? 1 : -1;
+			return (await collection(table).find({
+				...Object.fromEntries(index.eq.map((column, at) => [column, request.eq[at]])),
+				...bounds.length > 0 && { $and: bounds }
+			}, {
+				sort: Object.fromEntries(columns.map((column) => [column, direction])),
+				limit: request.limit,
+				...options.batchSize && { batchSize: options.batchSize }
+			}).toArray()).map((document) => normalize(table, document));
+		},
+		async write(ops) {
+			const session = client.startSession();
+			let position = 0;
+			try {
+				session.startTransaction({
+					readConcern: { level: "snapshot" },
+					writeConcern: { w: "majority" }
+				});
+				for (; position < ops.length; position += 1) if (!await apply(ops[position], session)) {
+					await session.abortTransaction();
+					return {
+						ok: false,
+						failedOp: position
+					};
+				}
+				await session.commitTransaction().catch(async (error) => {
+					if (!mongoError(error)?.hasErrorLabel("UnknownTransactionCommitResult")) throw error;
+					await session.commitTransaction();
+				});
+				return { ok: true };
+			} catch (error) {
+				if (session.inTransaction()) await session.abortTransaction().catch(() => void 0);
+				const failure = mongoError(error);
+				if (failure?.hasErrorLabel("TransientTransactionError") || failure?.code === 112) return {
+					ok: false,
+					retry: true
+				};
+				if (failure?.code === 11e3 && position < ops.length) return ops[position].type === "increment" ? {
+					ok: false,
+					retry: true
+				} : {
+					ok: false,
+					failedOp: position
+				};
+				throw failure?.code === 20 ? new MongoTransactionUnsupportedError(error) : error;
+			} finally {
+				await session.endSession();
+			}
+		},
+		migrations: { async apply(tables) {
+			for (const table of tables) {
+				await client.db().createCollection(tablePrefix + table.name).catch((error) => {
+					if (mongoError(error)?.code !== 48) throw error;
+				});
+				if (table.indexes.length === 0) continue;
+				await collection(table).createIndexes(table.indexes.map((index) => indexDescription(table, index)));
+			}
+		} }
+	};
+};
+//#endregion
+exports.MongoTransactionUnsupportedError = MongoTransactionUnsupportedError;
+exports.createMongoAdapter = createMongoAdapter;

package/dist/adapters/mongodbAdapter.d.cts

@@ -0,0 +1,9 @@
+import { DatabaseAdapter } from "@hot-updater/plugin-core/internal";
+import { MongoClient } from "mongodb";
+//#region src/adapters/mongodbAdapter.d.ts
+declare class MongoTransactionUnsupportedError extends Error {
+  readonly name = "MongoTransactionUnsupportedError";
+  constructor(cause: unknown);
+}
+//#endregion
+export { MongoTransactionUnsupportedError };

package/dist/adapters/mongodbAdapter.d.mts

@@ -0,0 +1,9 @@
+import { DatabaseAdapter } from "@hot-updater/plugin-core/internal";
+import { MongoClient } from "mongodb";
+//#region src/adapters/mongodbAdapter.d.ts
+declare class MongoTransactionUnsupportedError extends Error {
+  readonly name = "MongoTransactionUnsupportedError";
+  constructor(cause: unknown);
+}
+//#endregion
+export { MongoTransactionUnsupportedError };