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

package/dist/adapters/kyselyCrud.mjs

@@ -0,0 +1,253 @@
+import { isChannelDeleteReferencedError, translateChannelDeleteError } from "./databaseConstraintErrors.mjs";
+import { fromStoredBundleRow, fromStoredReleaseCatalogRow, fromStoredReleaseRow, toStoredBundleRow, toStoredBundleUpdate, toStoredReleaseRow, toStoredReleaseUpdate } from "./databasePluginUtils.mjs";
+import { buildKyselyWhere } from "./kyselyQuery.mjs";
+import { DatabasePluginInputError } from "@hot-updater/plugin-core";
+import { sql } from "kysely";
+//#region src/adapters/kyselyCrud.ts
+var KyselyAdapterInvariantError = class extends Error {
+	name = "KyselyAdapterInvariantError";
+	constructor(reason) {
+		super(`Kysely plugin invariant failed: ${reason}`);
+		this.reason = reason;
+	}
+};
+const empty = sql``;
+const lockClause = (provider, relationMode) => relationMode === "fumadb" && provider !== "sqlite" ? sql` for update` : empty;
+const whereClause = (where) => where === void 0 ? empty : sql` where ${where}`;
+const orderClause = (input) => {
+	const clauses = input?.orderBy;
+	if (clauses === void 0 || clauses.length === 0) return empty;
+	return sql` order by ${sql.join(clauses.map((clause) => {
+		const field = sql.ref(clause.field);
+		return sql`${(clause.nulls ?? (clause.direction === "asc" ? "last" : "first")) === "first" ? sql`${field} is null desc` : sql`${field} is null asc`}, ${clause.direction === "asc" ? sql`${field} asc` : sql`${field} desc`}`;
+	}), sql`, `)}`;
+};
+const insertRow = async (executor, table, row, provider, onConflict = void 0) => {
+	const entries = Object.entries(row);
+	const columns = sql.join(entries.map(([field]) => sql.ref(field)));
+	const values = sql.join(entries.map(([, value]) => value));
+	const result = onConflict === void 0 ? await sql`insert into ${sql.table(table)} (${columns}) values (${values})`.execute(executor) : provider === "mysql" ? await sql`insert ignore into ${sql.table(table)} (${columns}) values (${values})`.execute(executor) : provider === "sqlite" ? await sql`insert or ignore into ${sql.table(table)} (${columns}) values (${values})`.execute(executor) : await sql`insert into ${sql.table(table)} (${columns}) values (${values}) on conflict do nothing`.execute(executor);
+	return Number(result.numAffectedRows ?? 0) > 0;
+};
+const updateBundle = async (executor, id, update) => {
+	const assignments = Object.entries(update).filter(([, value]) => value !== void 0).map(([field, value]) => sql`${sql.ref(field)} = ${value}`);
+	if (assignments.length === 0) return;
+	await sql`update ${sql.table("bundles")} set ${sql.join(assignments)} where ${sql.ref("id")} = ${id}`.execute(executor);
+};
+const updateApiKey = async (executor, id, revokedAtMs) => {
+	await sql`update ${sql.table("api_keys")} set ${sql.ref("revoked_at_ms")} = ${revokedAtMs} where ${sql.ref("id")} = ${id}`.execute(executor);
+};
+const updateRow = async (executor, table, keyField, key, update) => {
+	const assignments = Object.entries(update).filter(([, value]) => value !== void 0).map(([field, value]) => sql`${sql.ref(field)} = ${value}`);
+	if (assignments.length === 0) return;
+	await sql`update ${sql.table(table)} set ${sql.join(assignments)} where ${sql.ref(keyField)} = ${key}`.execute(executor);
+};
+const assertBundleReferences = async (executor, provider, relationMode, bundleId, baseBundleId) => {
+	const ids = [...new Set([bundleId, baseBundleId])].sort((left, right) => left.localeCompare(right));
+	const result = await sql`select ${sql.ref("id")} from ${sql.table("bundles")} where ${sql.ref("id")} in (${sql.join(ids)}) order by ${sql.ref("id")}${lockClause(provider, relationMode)}`.execute(executor);
+	const storedIds = new Set(result.rows.map(({ id }) => id));
+	if (!storedIds.has(bundleId)) throw new KyselyAdapterInvariantError("bundle_patches.bundle_id.foreign-key");
+	if (!storedIds.has(baseBundleId)) throw new KyselyAdapterInvariantError("bundle_patches.base_bundle_id.foreign-key");
+};
+const countRows = async (executor, table, where) => {
+	const result = await sql`select count(${sql.ref("id")}) as ${sql.ref("total")} from ${sql.table(table)}${whereClause(where)}`.execute(executor);
+	return Number(result.rows[0]?.total ?? 0);
+};
+const createKyselyCrud = (executor, provider, relationMode = "foreign-keys") => ({
+	async deleteChannel({ id }) {
+		if ((await sql`select ${sql.ref("id")}, ${sql.ref("name")} from ${sql.table("channels")} where ${sql.ref("id")} = ${id} limit 1${lockClause(provider, relationMode)}`.execute(executor)).rows[0] === void 0) return {
+			deleted: false,
+			reason: "not_found"
+		};
+		if (await countRows(executor, "releases", sql`${sql.ref("channel_id")} = ${id}`) > 0) return {
+			deleted: false,
+			reason: "not_empty"
+		};
+		try {
+			await sql`delete from ${sql.table("channels")} where ${sql.ref("id")} = ${id}`.execute(executor);
+		} catch (error) {
+			if (isChannelDeleteReferencedError(error)) return {
+				deleted: false,
+				reason: "not_empty"
+			};
+			throw error;
+		}
+		return { deleted: true };
+	},
+	async insertChannel(input) {
+		const inserted = await insertRow(executor, "channels", input.row, provider, "ignore");
+		const row = (await sql`select ${sql.ref("id")}, ${sql.ref("name")} from ${sql.table("channels")} where ${sql.ref("name")} = ${input.row.name} limit 1`.execute(executor)).rows[0];
+		if (row === void 0) throw new KyselyAdapterInvariantError("channels.insert.return-existing");
+		return {
+			row,
+			inserted
+		};
+	},
+	async create(input) {
+		switch (input.model) {
+			case "bundles":
+				await insertRow(executor, "bundles", toStoredBundleRow(input.data, provider), provider);
+				return input.data;
+			case "bundle_patches":
+				await assertBundleReferences(executor, provider, relationMode, input.data.bundle_id, input.data.base_bundle_id);
+				await insertRow(executor, "bundle_patches", input.data, provider);
+				return input.data;
+			case "bundle_events":
+				await insertRow(executor, "bundle_events", input.data, provider);
+				return input.data;
+			case "releases":
+				await insertRow(executor, "releases", toStoredReleaseRow(input.data, provider), provider);
+				return input.data;
+			case "release_catalogs":
+				await insertRow(executor, "release_catalogs", input.data, provider);
+				return input.data;
+			case "api_keys":
+				await insertRow(executor, "api_keys", input.data, provider, input.onConflict);
+				return input.data;
+			case "channels":
+				await insertRow(executor, "channels", input.data, provider, input.onConflict);
+				return input.data;
+		}
+	},
+	async update(input) {
+		const selector = input.where[0];
+		if (selector === void 0 || typeof selector.value !== "string") throw new KyselyAdapterInvariantError(`${input.model}.update.selector`);
+		if (input.model === "api_keys") {
+			await updateApiKey(executor, selector.value, input.update.revoked_at_ms);
+			return (await sql`select * from ${sql.table("api_keys")} where ${sql.ref("id")} = ${selector.value} limit 1`.execute(executor)).rows[0] ?? null;
+		}
+		if (input.model === "releases") {
+			await updateRow(executor, "releases", "id", selector.value, toStoredReleaseUpdate(input.update, provider));
+			const row = (await sql`select * from ${sql.table("releases")} where ${sql.ref("id")} = ${selector.value} limit 1`.execute(executor)).rows[0];
+			return row === void 0 ? null : fromStoredReleaseRow(row);
+		}
+		if (input.model === "release_catalogs") {
+			await updateRow(executor, "release_catalogs", "scope_key", selector.value, input.update);
+			const row = (await sql`select * from ${sql.table("release_catalogs")} where ${sql.ref("scope_key")} = ${selector.value} limit 1`.execute(executor)).rows[0];
+			return row === void 0 ? null : fromStoredReleaseCatalogRow(row);
+		}
+		await updateBundle(executor, selector.value, toStoredBundleUpdate(input.update, provider));
+		const stored = (await sql`select * from ${sql.table("bundles")} where ${sql.ref("id")} = ${selector.value} limit 1`.execute(executor)).rows[0];
+		if (stored === void 0) return null;
+		return fromStoredBundleRow(stored);
+	},
+	async delete(input) {
+		switch (input.model) {
+			case "bundles": {
+				const where = buildKyselyWhere(provider, input.where);
+				if (where === void 0) throw new KyselyAdapterInvariantError("bundles.delete.where");
+				if (relationMode === "fumadb") {
+					const bundleIds = (await sql`select ${sql.ref("id")} from ${sql.table("bundles")} where ${where} order by ${sql.ref("id")}${lockClause(provider, relationMode)}`.execute(executor)).rows.map(({ id }) => id);
+					if (bundleIds.length === 0) return;
+					await sql`delete from ${sql.table("bundle_patches")} where ${sql.ref("bundle_id")} in (${sql.join(bundleIds)}) or ${sql.ref("base_bundle_id")} in (${sql.join(bundleIds)})`.execute(executor);
+				}
+				await sql`delete from ${sql.table("bundles")} where ${where}`.execute(executor);
+				return;
+			}
+			case "bundle_patches": {
+				const where = buildKyselyWhere(provider, input.where);
+				if (where === void 0) throw new KyselyAdapterInvariantError("bundle_patches.delete.where");
+				await sql`delete from ${sql.table("bundle_patches")} where ${where}`.execute(executor);
+				return;
+			}
+			case "releases": {
+				const where = buildKyselyWhere(provider, input.where);
+				if (where === void 0) throw new KyselyAdapterInvariantError("releases.delete.where");
+				await sql`delete from ${sql.table("releases")} where ${where}`.execute(executor);
+				return;
+			}
+			case "channels": {
+				const where = buildKyselyWhere(provider, input.where);
+				if (where === void 0) throw new KyselyAdapterInvariantError("channels.delete.where");
+				try {
+					await sql`delete from ${sql.table("channels")} where ${where}`.execute(executor);
+				} catch (error) {
+					translateChannelDeleteError(error);
+				}
+				return;
+			}
+		}
+	},
+	async count(input) {
+		if (input.distinct !== void 0) throw new DatabasePluginInputError("invalid-operation");
+		switch (input.model) {
+			case "bundles": return countRows(executor, "bundles", buildKyselyWhere(provider, input.where));
+			case "bundle_patches": return countRows(executor, "bundle_patches", buildKyselyWhere(provider, input.where));
+			case "releases": return countRows(executor, "releases", buildKyselyWhere(provider, input.where));
+		}
+	},
+	async findOne(input) {
+		switch (input.model) {
+			case "bundles": {
+				const where = whereClause(buildKyselyWhere(provider, input.where));
+				const row = (await sql`select * from ${sql.table("bundles")}${where} limit 1`.execute(executor)).rows[0];
+				return row === void 0 ? null : fromStoredBundleRow(row);
+			}
+			case "bundle_patches": {
+				const where = whereClause(buildKyselyWhere(provider, input.where));
+				return (await sql`select * from ${sql.table("bundle_patches")}${where} limit 1`.execute(executor)).rows[0] ?? null;
+			}
+			case "api_keys": {
+				const where = whereClause(buildKyselyWhere(provider, input.where));
+				return (await sql`select * from ${sql.table("api_keys")}${where} limit 1`.execute(executor)).rows[0] ?? null;
+			}
+			case "channels": {
+				const where = whereClause(buildKyselyWhere(provider, input.where));
+				return (await sql`select * from ${sql.table("channels")}${where} limit 1`.execute(executor)).rows[0] ?? null;
+			}
+			case "releases": {
+				const where = whereClause(buildKyselyWhere(provider, input.where));
+				const row = (await sql`select * from ${sql.table("releases")}${where} limit 1`.execute(executor)).rows[0];
+				return row === void 0 ? null : fromStoredReleaseRow(row);
+			}
+			case "release_catalogs": {
+				const where = whereClause(buildKyselyWhere(provider, input.where));
+				const row = (await sql`select * from ${sql.table("release_catalogs")}${where} limit 1`.execute(executor)).rows[0];
+				return row === void 0 ? null : fromStoredReleaseCatalogRow(row);
+			}
+		}
+	},
+	async findMany(input) {
+		if (input.distinctOn !== void 0) throw new DatabasePluginInputError("invalid-operation");
+		const pagination = sql` limit ${input.limit} offset ${input.offset}`;
+		switch (input.model) {
+			case "bundles": {
+				const where = whereClause(buildKyselyWhere(provider, input.where));
+				const order = orderClause(input);
+				return (await sql`select * from ${sql.table("bundles")}${where}${order}${pagination}`.execute(executor)).rows.map(fromStoredBundleRow);
+			}
+			case "bundle_patches": {
+				const where = whereClause(buildKyselyWhere(provider, input.where));
+				const order = orderClause(input);
+				return [...(await sql`select * from ${sql.table("bundle_patches")}${where}${order}${pagination}`.execute(executor)).rows];
+			}
+			case "bundle_events": {
+				const where = whereClause(buildKyselyWhere(provider, input.where));
+				const order = orderClause(input);
+				return [...(await sql`select * from ${sql.table("bundle_events")}${where}${order}${pagination}`.execute(executor)).rows];
+			}
+			case "api_keys": {
+				const where = whereClause(buildKyselyWhere(provider, input.where));
+				const order = orderClause(input);
+				return [...(await sql`select * from ${sql.table("api_keys")}${where}${order}${pagination}`.execute(executor)).rows];
+			}
+			case "channels": {
+				const where = whereClause(buildKyselyWhere(provider, input.where));
+				const order = orderClause(input);
+				return [...(await sql`select * from ${sql.table("channels")}${where}${order}${pagination}`.execute(executor)).rows];
+			}
+			case "releases": {
+				const where = whereClause(buildKyselyWhere(provider, input.where));
+				const order = orderClause(input);
+				return (await sql`select * from ${sql.table("releases")}${where}${order}${pagination}`.execute(executor)).rows.map(fromStoredReleaseRow);
+			}
+			case "release_catalogs": {
+				const where = whereClause(buildKyselyWhere(provider, input.where));
+				const order = orderClause(input);
+				return (await sql`select * from ${sql.table("release_catalogs")}${where}${order}${pagination}`.execute(executor)).rows.map(fromStoredReleaseCatalogRow);
+			}
+		}
+	}
+});
+//#endregion
+export { createKyselyCrud };

package/dist/adapters/kyselyQuery.cjs

@@ -0,0 +1,56 @@
+require("../_virtual/_rolldown/runtime.cjs");
+const require_databasePluginUtils = require("./databasePluginUtils.cjs");
+let kysely = require("kysely");
+//#region src/adapters/kyselyQuery.ts
+var InvalidDatabasePredicateError = class extends Error {
+	name = "InvalidDatabasePredicateError";
+};
+const stringPredicate = (provider, field, operator, value, insensitive) => {
+	const column = kysely.sql.ref(field);
+	if (provider === "sqlite" && !insensitive) {
+		const literal = require_databasePluginUtils.escapeGlobPattern(value);
+		return kysely.sql`${column} glob ${operator === "contains" ? `*${literal}*` : operator === "starts_with" ? `${literal}*` : `*${literal}`}`;
+	}
+	const literal = require_databasePluginUtils.escapeLikePattern(value);
+	const pattern = operator === "contains" ? `%${literal}%` : operator === "starts_with" ? `${literal}%` : `%${literal}`;
+	if (insensitive) return kysely.sql`lower(${column}) like lower(${pattern}) escape '\\'`;
+	if (provider === "mysql") return kysely.sql`binary ${column} like binary ${pattern} escape '\\'`;
+	return kysely.sql`${column} like ${pattern} escape '\\'`;
+};
+const predicate = (provider, condition) => {
+	const column = kysely.sql.ref(condition.field);
+	const operator = condition.operator ?? "eq";
+	switch (operator) {
+		case "eq":
+		case "ne":
+			if (condition.value === null) return operator === "eq" ? kysely.sql`${column} is null` : kysely.sql`${column} is not null`;
+			if ("mode" in condition && condition.mode === "insensitive") return operator === "eq" ? kysely.sql`lower(${column}) = lower(${condition.value})` : kysely.sql`lower(${column}) <> lower(${condition.value})`;
+			return operator === "eq" ? kysely.sql`${column} = ${condition.value}` : kysely.sql`${column} <> ${condition.value}`;
+		case "gt": return kysely.sql`${column} > ${condition.value}`;
+		case "gte": return kysely.sql`${column} >= ${condition.value}`;
+		case "lt": return kysely.sql`${column} < ${condition.value}`;
+		case "lte": return kysely.sql`${column} <= ${condition.value}`;
+		case "in":
+		case "not_in":
+			if (!Array.isArray(condition.value)) throw new InvalidDatabasePredicateError();
+			if (operator === "in") return condition.value.length === 0 ? kysely.sql`false` : kysely.sql`${column} in (${kysely.sql.join(condition.value)})`;
+			return condition.value.length === 0 ? kysely.sql`true` : kysely.sql`${column} not in (${kysely.sql.join(condition.value)})`;
+		case "contains":
+		case "starts_with":
+		case "ends_with":
+			if (typeof condition.value !== "string") throw new InvalidDatabasePredicateError();
+			return stringPredicate(provider, condition.field, operator, condition.value, "mode" in condition && condition.mode === "insensitive");
+	}
+};
+const buildKyselyWhere = (provider, where) => {
+	const [first, ...rest] = where ?? [];
+	if (first === void 0) return void 0;
+	let expression = predicate(provider, first);
+	for (const condition of rest) {
+		const next = predicate(provider, condition);
+		expression = condition.connector === "OR" ? kysely.sql`(${expression} or ${next})` : kysely.sql`(${expression} and ${next})`;
+	}
+	return expression;
+};
+//#endregion
+exports.buildKyselyWhere = buildKyselyWhere;

package/dist/adapters/kyselyQuery.mjs

@@ -0,0 +1,55 @@
+import { escapeGlobPattern, escapeLikePattern } from "./databasePluginUtils.mjs";
+import { sql } from "kysely";
+//#region src/adapters/kyselyQuery.ts
+var InvalidDatabasePredicateError = class extends Error {
+	name = "InvalidDatabasePredicateError";
+};
+const stringPredicate = (provider, field, operator, value, insensitive) => {
+	const column = sql.ref(field);
+	if (provider === "sqlite" && !insensitive) {
+		const literal = escapeGlobPattern(value);
+		return sql`${column} glob ${operator === "contains" ? `*${literal}*` : operator === "starts_with" ? `${literal}*` : `*${literal}`}`;
+	}
+	const literal = escapeLikePattern(value);
+	const pattern = operator === "contains" ? `%${literal}%` : operator === "starts_with" ? `${literal}%` : `%${literal}`;
+	if (insensitive) return sql`lower(${column}) like lower(${pattern}) escape '\\'`;
+	if (provider === "mysql") return sql`binary ${column} like binary ${pattern} escape '\\'`;
+	return sql`${column} like ${pattern} escape '\\'`;
+};
+const predicate = (provider, condition) => {
+	const column = sql.ref(condition.field);
+	const operator = condition.operator ?? "eq";
+	switch (operator) {
+		case "eq":
+		case "ne":
+			if (condition.value === null) return operator === "eq" ? sql`${column} is null` : sql`${column} is not null`;
+			if ("mode" in condition && condition.mode === "insensitive") return operator === "eq" ? sql`lower(${column}) = lower(${condition.value})` : sql`lower(${column}) <> lower(${condition.value})`;
+			return operator === "eq" ? sql`${column} = ${condition.value}` : sql`${column} <> ${condition.value}`;
+		case "gt": return sql`${column} > ${condition.value}`;
+		case "gte": return sql`${column} >= ${condition.value}`;
+		case "lt": return sql`${column} < ${condition.value}`;
+		case "lte": return sql`${column} <= ${condition.value}`;
+		case "in":
+		case "not_in":
+			if (!Array.isArray(condition.value)) throw new InvalidDatabasePredicateError();
+			if (operator === "in") return condition.value.length === 0 ? sql`false` : sql`${column} in (${sql.join(condition.value)})`;
+			return condition.value.length === 0 ? sql`true` : sql`${column} not in (${sql.join(condition.value)})`;
+		case "contains":
+		case "starts_with":
+		case "ends_with":
+			if (typeof condition.value !== "string") throw new InvalidDatabasePredicateError();
+			return stringPredicate(provider, condition.field, operator, condition.value, "mode" in condition && condition.mode === "insensitive");
+	}
+};
+const buildKyselyWhere = (provider, where) => {
+	const [first, ...rest] = where ?? [];
+	if (first === void 0) return void 0;
+	let expression = predicate(provider, first);
+	for (const condition of rest) {
+		const next = predicate(provider, condition);
+		expression = condition.connector === "OR" ? sql`(${expression} or ${next})` : sql`(${expression} and ${next})`;
+	}
+	return expression;
+};
+//#endregion
+export { buildKyselyWhere };

package/dist/adapters/mongodb.cjs

@@ -1,187 +1,34 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 require("../_virtual/_rolldown/runtime.cjs");
-const require_bundleRows = require("../db/bundleRows.cjs");
-const require_fixedMigrator = require("../db/fixedMigrator.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_core = require("@hot-updater/core");
+let _hot_updater_plugin_core_internal = require("@hot-updater/plugin-core/internal");
 //#region src/adapters/mongodb.ts
-const mongoWhere = (where) => {
-	const baseFilter = {
-		...where?.channel !== void 0 ? { channel: where.channel } : {},
-		...where?.platform !== void 0 ? { platform: where.platform } : {},
-		...where?.enabled !== void 0 ? { enabled: where.enabled } : {},
-		...where?.fingerprintHash !== void 0 ? where.fingerprintHash === null ? { fingerprint_hash: { $in: [null, ""] } } : { fingerprint_hash: where.fingerprintHash } : {},
-		...where?.id ? { id: {
-			...where.id.eq !== void 0 ? { $eq: where.id.eq } : {},
-			...where.id.gt !== void 0 ? { $gt: where.id.gt } : {},
-			...where.id.gte !== void 0 ? { $gte: where.id.gte } : {},
-			...where.id.lt !== void 0 ? { $lt: where.id.lt } : {},
-			...where.id.lte !== void 0 ? { $lte: where.id.lte } : {},
-			...where.id.in !== void 0 ? { $in: where.id.in } : {}
-		} } : {}
+const createMongoImplementation = (client, session) => {
+	const collections = require_mongodbCollections.createMongoCollections(client);
+	return {
+		...require_mongodbWrites.createMongoWrites(collections, session),
+		...require_mongodbReads.createMongoReads(collections, session)
 	};
-	const targetAppVersionFilters = [];
-	if (where?.targetAppVersion !== void 0) targetAppVersionFilters.push(where.targetAppVersion === null ? { target_app_version: { $in: [null, ""] } } : { target_app_version: where.targetAppVersion });
-	if (where?.targetAppVersionIn) targetAppVersionFilters.push({ target_app_version: { $in: where.targetAppVersionIn } });
-	if (where?.targetAppVersionNotNull) targetAppVersionFilters.push({ target_app_version: {
-		$exists: true,
-		$nin: [null, ""]
-	} });
-	const filters = [...Object.keys(baseFilter).length > 0 ? [baseFilter] : [], ...targetAppVersionFilters];
-	if (filters.length === 0) return {};
-	if (filters.length === 1) return filters[0] ?? {};
-	return { $and: filters };
 };
-const createMongoPlugin = (0, _hot_updater_plugin_core.createDatabasePlugin)({
-	name: "mongodb",
-	factory: ({ client }) => {
-		const db = client.db();
-		const bundles = db.collection("bundles");
-		const patches = db.collection("bundle_patches");
-		const fetchPatchMap = async (bundleIds) => {
-			const patchMap = /* @__PURE__ */ new Map();
-			if (bundleIds.length === 0) return patchMap;
-			const rows = await patches.find({ bundle_id: { $in: [...bundleIds] } }).sort({ order_index: 1 }).toArray();
-			for (const row of rows) {
-				const current = patchMap.get(row.bundle_id) ?? [];
-				current.push(row);
-				patchMap.set(row.bundle_id, current);
-			}
-			return patchMap;
-		};
-		const mapRowsToBundles = async (rows) => {
-			const patchMap = await fetchPatchMap(rows.map((row) => row.id));
-			return rows.map((row) => require_bundleRows.rowToBundle(row, patchMap.get(row.id) ?? []));
-		};
-		const isTransactionUnsupported = (error) => error instanceof Error && /Transaction numbers are only allowed|replica set member or mongos|Transaction API error/i.test(error.message);
-		const runInTransaction = async (operation) => {
-			if (typeof client.startSession !== "function") return operation(void 0);
-			const session = client.startSession();
-			try {
-				if (typeof session.withTransaction !== "function") return await operation(session);
-				let result;
-				await session.withTransaction(async () => {
-					result = await operation(session);
-				});
-				return result;
-			} catch (error) {
-				if (isTransactionUnsupported(error)) return operation(void 0);
-				throw error;
-			} finally {
-				await session.endSession();
-			}
-		};
-		const replaceBundle = async (bundle, session) => {
-			const row = require_bundleRows.bundleToRow(bundle);
-			await bundles.updateOne({ id: bundle.id }, { $set: row }, {
-				session,
-				upsert: true
-			});
-			await patches.deleteMany({ bundle_id: bundle.id }, { session });
-			const patchRows = require_bundleRows.bundleToPatchRows(bundle);
-			if (patchRows.length > 0) await patches.insertMany(patchRows, { session });
-		};
-		const deleteByBundleId = async (collection, field, bundleId, session) => {
-			await collection.deleteMany({ [field]: bundleId }, { session });
-		};
-		return {
-			async getBundleById(bundleId) {
-				const row = await bundles.findOne({ id: bundleId });
-				if (!row) return null;
-				return require_bundleRows.rowToBundle(row, (await fetchPatchMap([bundleId])).get(bundleId) ?? []);
-			},
-			async getBundles(options) {
-				const offset = options.offset ?? 0;
-				const orderBy = options.orderBy ?? {
-					field: "id",
-					direction: "desc"
-				};
-				const where = mongoWhere(options.where);
-				const [total, rows] = await Promise.all([bundles.countDocuments(where), bundles.find(where).sort({ id: orderBy.direction === "asc" ? 1 : -1 }).skip(offset).limit(options.limit).toArray()]);
-				const patchMap = await fetchPatchMap(rows.map((row) => row.id));
-				return {
-					data: rows.map((row) => require_bundleRows.rowToBundle(row, patchMap.get(row.id) ?? [])),
-					pagination: (0, _hot_updater_plugin_core.calculatePagination)(total, {
-						limit: options.limit,
-						offset
-					})
-				};
-			},
-			async getUpdateInfo(args, context) {
-				if (args._updateStrategy === "appVersion") {
-					const channel = args.channel ?? "production";
-					const minBundleId = args.minBundleId ?? _hot_updater_core.NIL_UUID;
-					const rows = await bundles.find({
-						enabled: true,
-						platform: args.platform,
-						channel,
-						id: { $gte: minBundleId },
-						target_app_version: {
-							$exists: true,
-							$nin: [null, ""]
-						}
-					}).project({ target_app_version: 1 }).toArray();
-					const compatibleAppVersions = (0, _hot_updater_plugin_core.filterCompatibleAppVersions)(Array.from(new Set(rows.map((row) => row.target_app_version).filter((value) => typeof value === "string" && value.length > 0))), args.appVersion);
-					const updateRows = compatibleAppVersions.length > 0 ? await bundles.find({
-						enabled: true,
-						platform: args.platform,
-						channel,
-						id: { $gte: minBundleId },
-						target_app_version: { $in: compatibleAppVersions }
-					}).sort({ id: -1 }).toArray() : [];
-					return (0, _hot_updater_plugin_core.resolveUpdateInfoFromBundles)({
-						args: {
-							...args,
-							channel,
-							minBundleId
-						},
-						bundles: await mapRowsToBundles(updateRows),
-						context
-					});
-				}
-				const channel = args.channel ?? "production";
-				const minBundleId = args.minBundleId ?? _hot_updater_core.NIL_UUID;
-				const rows = await bundles.find({
-					enabled: true,
-					platform: args.platform,
-					channel,
-					id: { $gte: minBundleId },
-					fingerprint_hash: args.fingerprintHash
-				}).sort({ id: -1 }).toArray();
-				return (0, _hot_updater_plugin_core.resolveUpdateInfoFromBundles)({
-					args: {
-						...args,
-						channel,
-						minBundleId
-					},
-					bundles: await mapRowsToBundles(rows),
-					context
-				});
-			},
-			async getChannels() {
-				return (await bundles.distinct("channel")).filter((channel) => typeof channel === "string").sort((left, right) => left.localeCompare(right));
-			},
-			async commitBundle({ changedSets }) {
-				await runInTransaction(async (session) => {
-					for (const change of changedSets) {
-						if (change.operation === "delete") {
-							await deleteByBundleId(patches, "bundle_id", change.data.id, session);
-							await deleteByBundleId(patches, "base_bundle_id", change.data.id, session);
-							await bundles.deleteMany({ id: change.data.id }, { session });
-							continue;
-						}
-						await replaceBundle(change.data, session);
-					}
-				});
-			}
-		};
-	}
+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) => {
-	return Object.assign(createMongoPlugin(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",
 		provider: "mongodb",
-		createMigrator: () => require_fixedMigrator.createMongoMigrator(config.client)
+		createMigrator: () => require_fixedMigratorMongo.createMongoMigrator(config.client)
 	});
 };
 //#endregion

package/dist/adapters/mongodb.d.cts

@@ -1,10 +1,11 @@
-import { DatabasePluginFactory } from "../db/types.cjs";
+import { DatabaseAdapterWithCapabilities } from "../db/types.cjs";
 import { MongoClient } from "mongodb";
 
 //#region src/adapters/mongodb.d.ts
 interface MongoDBConfig {
   readonly client: MongoClient;
+  readonly transactions?: boolean;
 }
-declare const mongoAdapter: (config: MongoDBConfig) => DatabasePluginFactory;
+declare const mongoAdapter: (config: MongoDBConfig) => DatabaseAdapterWithCapabilities;
 //#endregion
 export { MongoDBConfig, mongoAdapter };

package/dist/adapters/mongodb.d.mts

@@ -1,10 +1,11 @@
-import { DatabasePluginFactory } from "../db/types.mjs";
+import { DatabaseAdapterWithCapabilities } from "../db/types.mjs";
 import { MongoClient } from "mongodb";
 
 //#region src/adapters/mongodb.d.ts
 interface MongoDBConfig {
   readonly client: MongoClient;
+  readonly transactions?: boolean;
 }
-declare const mongoAdapter: (config: MongoDBConfig) => DatabasePluginFactory;
+declare const mongoAdapter: (config: MongoDBConfig) => DatabaseAdapterWithCapabilities;
 //#endregion
 export { MongoDBConfig, mongoAdapter };