@hot-updater/server 1.0.0-rc.2 → 1.0.0-rc.21

package/dist/adapters/kysely.d.cts

@@ -1,12 +1,16 @@
-import { DatabaseAdapterWithCapabilities, ORMSQLProvider, RelationMode } from "../db/types.cjs";
+import { kyselyExecutor } from "./kyselyExecutor.cjs";
+import { SqlDialect, ToolingDatabase } from "@hot-updater/plugin-core";
 import { Kysely } from "kysely";
 //#region src/adapters/kysely.d.ts
-type KyselySQLProvider = Exclude<ORMSQLProvider, "mssql">;
 interface KyselyAdapterConfig<TDatabase extends object = object> {
   readonly db: Kysely<TDatabase>;
-  readonly provider: KyselySQLProvider;
-  readonly relationMode?: RelationMode;
+  readonly provider: SqlDialect;
 }
-declare const kyselyAdapter: <TDatabase extends object>(config: KyselyAdapterConfig<TDatabase>) => DatabaseAdapterWithCapabilities;
+/**
+ * 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.
+ */
+declare const kyselyAdapter: <TDatabase extends object>(config: KyselyAdapterConfig<TDatabase>) => ToolingDatabase;
 //#endregion
-export { KyselyAdapterConfig, type RelationMode, type KyselySQLProvider as SQLProvider, kyselyAdapter };
+export { KyselyAdapterConfig, type SqlDialect as SQLProvider, kyselyAdapter, kyselyExecutor };

package/dist/adapters/kysely.d.mts

@@ -1,12 +1,16 @@
-import { DatabaseAdapterWithCapabilities, ORMSQLProvider, RelationMode } from "../db/types.mjs";
+import { kyselyExecutor } from "./kyselyExecutor.mjs";
+import { SqlDialect, ToolingDatabase } from "@hot-updater/plugin-core";
 import { Kysely } from "kysely";
 //#region src/adapters/kysely.d.ts
-type KyselySQLProvider = Exclude<ORMSQLProvider, "mssql">;
 interface KyselyAdapterConfig<TDatabase extends object = object> {
   readonly db: Kysely<TDatabase>;
-  readonly provider: KyselySQLProvider;
-  readonly relationMode?: RelationMode;
+  readonly provider: SqlDialect;
 }
-declare const kyselyAdapter: <TDatabase extends object>(config: KyselyAdapterConfig<TDatabase>) => DatabaseAdapterWithCapabilities;
+/**
+ * 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.
+ */
+declare const kyselyAdapter: <TDatabase extends object>(config: KyselyAdapterConfig<TDatabase>) => ToolingDatabase;
 //#endregion
-export { KyselyAdapterConfig, type RelationMode, type KyselySQLProvider as SQLProvider, kyselyAdapter };
+export { KyselyAdapterConfig, type SqlDialect as SQLProvider, kyselyAdapter, kyselyExecutor };

package/dist/adapters/kysely.mjs

@@ -1,38 +1,28 @@
-import { createKyselyMigrator } from "../db/fixedMigrator.mjs";
-import { runInsightsTransaction } from "./insightsTransaction.mjs";
-import { createKyselyCrud, recordKyselyInsights } from "./kyselyCrud.mjs";
-import { createDatabasePlugin } from "@hot-updater/plugin-core";
-import { createDatabasePluginAdapter } from "@hot-updater/plugin-core/internal";
+import { kyselyExecutor } from "./kyselyExecutor.mjs";
+import { checkSqlProvider } from "./sqlProviders.mjs";
+import { coreTarget, createEngineDatabase, createEngineSqlMigrator, createSqlAdapter } from "@hot-updater/plugin-core";
 //#region src/adapters/kysely.ts
-const createImplementation = (config) => {
-	const db = config.db;
-	const relationMode = config.relationMode ?? "foreign-keys";
-	return {
-		...createKyselyCrud(db, config.provider, relationMode),
-		recordInsights: (input) => runInsightsTransaction(() => db.transaction().execute((transaction) => recordKyselyInsights(transaction, config.provider, input))),
-		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 } = coreTarget) => 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,11 @@
+import { SqlDialect, SqlExecutor } from "@hot-updater/plugin-core";
+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,11 @@
+import { SqlDialect, SqlExecutor } from "@hot-updater/plugin-core";
+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,61 +1,25 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-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");
+const require_mongodbAdapter = require("./mongodbAdapter.cjs");
 let _hot_updater_plugin_core = require("@hot-updater/plugin-core");
-let _hot_updater_plugin_core_internal = require("@hot-updater/plugin-core/internal");
-let mongodb = require("mongodb");
 //#region src/adapters/mongodb.ts
-const createMongoImplementation = (client, session) => {
-	const collections = require_mongodbCollections.createMongoCollections(client);
-	return {
-		recordInsights: async (input) => {
-			const record = () => client.withSession((recordSession) => recordSession.withTransaction(async () => {
-				const records = require_mongodbCollections.createMongoCollections(client);
-				const options = {
-					session: recordSession,
-					collation: { locale: "simple" }
-				};
-				if ((await records.bundleEvents.updateOne({ id: input.event.id }, { $setOnInsert: input.event }, {
-					...options,
-					upsert: true
-				})).upsertedCount === 0) return;
-				const current = await records.bundleInstallations.findOne({ install_id: input.installation.install_id }, options);
-				if (current === null) await records.bundleInstallations.insertOne({ ...input.installation }, { session: recordSession });
-				else if (input.installation.received_at_ms > current.received_at_ms || input.installation.received_at_ms === current.received_at_ms && (0, _hot_updater_plugin_core.compareInsightsText)(input.installation.id, current.id) > 0) await records.bundleInstallations.updateOne({ install_id: input.installation.install_id }, { $set: input.installation }, options);
-			}, {
-				readConcern: { level: "snapshot" },
-				readPreference: "primary",
-				writeConcern: { w: "majority" }
-			}));
-			try {
-				await record();
-			} catch (error) {
-				if (!(error instanceof mongodb.MongoServerError) || error.code !== 11e3) throw error;
-				await record();
-			}
-		},
-		...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(_hot_updater_plugin_core.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))))
-});
-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)({
+/**
+* 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) => ({
+	...(0, _hot_updater_plugin_core.createEngineDatabase)({
 		name: "mongodb",
-		models: adapter.models,
-		commit: adapter.commit
-	}), {
-		adapterName: "mongodb",
-		provider: "mongodb",
-		createMigrator: () => require_fixedMigratorMongo.createMongoMigrator(config.client)
-	});
-};
+		adapter: require_mongodbAdapter.createMongoAdapter({ client: config.client }),
+		readSettings: readSettings(config.client)
+	}),
+	provider: "mongodb"
+});
 //#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 { MongoTransactionUnsupportedError } from "./mongodbAdapter.cjs";
+import { ToolingDatabase } from "@hot-updater/plugin-core";
 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;
-  /** Enables atomic catalog commits. Insights always requires MongoDB 5+ on a replica set or sharded cluster. */
-  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 { MongoTransactionUnsupportedError } from "./mongodbAdapter.mjs";
+import { ToolingDatabase } from "@hot-updater/plugin-core";
 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;
-  /** Enables atomic catalog commits. Insights always requires MongoDB 5+ on a replica set or sharded cluster. */
-  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,60 +1,23 @@
-import { createMongoMigrator } from "../db/fixedMigratorMongo.mjs";
-import { createMongoCollections } from "./mongodbCollections.mjs";
-import { createMongoReads } from "./mongodbReads.mjs";
-import { createMongoWrites } from "./mongodbWrites.mjs";
-import { compareInsightsText, createDatabasePlugin } from "@hot-updater/plugin-core";
-import { createDatabasePluginAdapter } from "@hot-updater/plugin-core/internal";
-import { MongoServerError } from "mongodb";
+import { MongoTransactionUnsupportedError, createMongoAdapter } from "./mongodbAdapter.mjs";
+import { SETTINGS_TABLE, createEngineDatabase } from "@hot-updater/plugin-core";
 //#region src/adapters/mongodb.ts
-const createMongoImplementation = (client, session) => {
-	const collections = createMongoCollections(client);
-	return {
-		recordInsights: async (input) => {
-			const record = () => client.withSession((recordSession) => recordSession.withTransaction(async () => {
-				const records = createMongoCollections(client);
-				const options = {
-					session: recordSession,
-					collation: { locale: "simple" }
-				};
-				if ((await records.bundleEvents.updateOne({ id: input.event.id }, { $setOnInsert: input.event }, {
-					...options,
-					upsert: true
-				})).upsertedCount === 0) return;
-				const current = await records.bundleInstallations.findOne({ install_id: input.installation.install_id }, options);
-				if (current === null) await records.bundleInstallations.insertOne({ ...input.installation }, { session: recordSession });
-				else if (input.installation.received_at_ms > current.received_at_ms || input.installation.received_at_ms === current.received_at_ms && compareInsightsText(input.installation.id, current.id) > 0) await records.bundleInstallations.updateOne({ install_id: input.installation.install_id }, { $set: input.installation }, options);
-			}, {
-				readConcern: { level: "snapshot" },
-				readPreference: "primary",
-				writeConcern: { w: "majority" }
-			}));
-			try {
-				await record();
-			} catch (error) {
-				if (!(error instanceof MongoServerError) || error.code !== 11e3) throw error;
-				await record();
-			}
-		},
-		...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))))
-});
-const mongoAdapter = (config) => {
-	const adapter = createDatabasePluginAdapter("mongodb", config.transactions === true ? createTransactionalMongoImplementation(config.client) : createMongoImplementation(config.client));
-	return Object.assign(createDatabasePlugin({
+/**
+* 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) => ({
+	...createEngineDatabase({
 		name: "mongodb",
-		models: adapter.models,
-		commit: adapter.commit
-	}), {
-		adapterName: "mongodb",
-		provider: "mongodb",
-		createMigrator: () => createMongoMigrator(config.client)
-	});
-};
+		adapter: createMongoAdapter({ client: config.client }),
+		readSettings: readSettings(config.client)
+	}),
+	provider: "mongodb"
+});
 //#endregion
-export { mongoAdapter };
+export { MongoTransactionUnsupportedError, mongoAdapter };

package/dist/adapters/mongodbAdapter.cjs

@@ -0,0 +1,192 @@
+let _hot_updater_plugin_core = require("@hot-updater/plugin-core");
+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.DATABASE_VERSION_COLUMN]: v
+};
+/** MongoDB's TTL monitor deletes a document once its `_expireAt` passes. */
+const TTL = {
+	name: "_expireAt",
+	key: { _expireAt: 1 },
+	expireAfterSeconds: 0
+};
+/** When a row with retention expires; a null retention column never does. */
+const expireAt = ({ retention }, row) => {
+	const at = row[retention.column];
+	return typeof at === "number" ? new Date(at + retention.ms) : null;
+};
+/** 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.rowKey)(table, row)),
+	...Object.fromEntries(table.columns.flatMap(({ name }) => row[name] === null || row[name] === void 0 ? [] : [[name, row[name]]])),
+	...table.retention && { [TTL.name]: expireAt(table, row) }
+});
+/** `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.indexOrderColumns)(table, index)];
+	const exists = columns.filter((column) => (0, _hot_updater_plugin_core.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.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.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;
+				if (op.table.retention) $set[TTL.name] = expireAt(op.table, {
+					...op.previous,
+					...op.set
+				});
+				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.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.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;
+				}
+				if (op.table.retention) set[TTL.name] = expireAt(op.table, op.init);
+				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.findPhysicalIndex)(table, request.index);
+			const columns = (0, _hot_updater_plugin_core.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.retention) await collection(table).createIndexes([TTL]);
+				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 "@hot-updater/plugin-core";
+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 "@hot-updater/plugin-core";
+import { MongoClient } from "mongodb";
+//#region src/adapters/mongodbAdapter.d.ts
+declare class MongoTransactionUnsupportedError extends Error {
+  readonly name = "MongoTransactionUnsupportedError";
+  constructor(cause: unknown);
+}
+//#endregion
+export { MongoTransactionUnsupportedError };