@hot-updater/server 0.36.6 → 1.0.0-rc.0

package/dist/adapters/mongodb.mjs

@@ -1,182 +1,29 @@
-import { bundleToPatchRows, bundleToRow, rowToBundle } from "../db/bundleRows.mjs";
-import { createMongoMigrator } from "../db/fixedMigrator.mjs";
-import { calculatePagination, createDatabasePlugin, filterCompatibleAppVersions, resolveUpdateInfoFromBundles } from "@hot-updater/plugin-core";
-import { NIL_UUID } from "@hot-updater/core";
+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";
 //#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 = createMongoCollections(client);
+	return {
+		...createMongoWrites(collections, session),
+		...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 = 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) => 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 = bundleToRow(bundle);
-			await bundles.updateOne({ id: bundle.id }, { $set: row }, {
-				session,
-				upsert: true
-			});
-			await patches.deleteMany({ bundle_id: bundle.id }, { session });
-			const patchRows = 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 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) => rowToBundle(row, patchMap.get(row.id) ?? [])),
-					pagination: calculatePagination(total, {
-						limit: options.limit,
-						offset
-					})
-				};
-			},
-			async getUpdateInfo(args, context) {
-				if (args._updateStrategy === "appVersion") {
-					const channel = args.channel ?? "production";
-					const minBundleId = args.minBundleId ?? 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 = 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 resolveUpdateInfoFromBundles({
-						args: {
-							...args,
-							channel,
-							minBundleId
-						},
-						bundles: await mapRowsToBundles(updateRows),
-						context
-					});
-				}
-				const channel = args.channel ?? "production";
-				const minBundleId = args.minBundleId ?? 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 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 = 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",
 		provider: "mongodb",
 		createMigrator: () => createMongoMigrator(config.client)

package/dist/adapters/mongodbCollections.cjs

@@ -0,0 +1,36 @@
+//#region src/adapters/mongodbCollections.ts
+var MongoAdapterConstraintError = class extends Error {
+	name = "MongoAdapterConstraintError";
+	constructor(reason) {
+		super(`MongoDB adapter constraint failed: ${reason}`);
+		this.reason = reason;
+	}
+};
+const WITHOUT_MONGO_ID = { _id: 0 };
+const DELETION_TOKEN_FIELD = "_hot_updater_deletion_token";
+const WITHOUT_INTERNAL_FIELDS = {
+	...WITHOUT_MONGO_ID,
+	[DELETION_TOKEN_FIELD]: 0
+};
+const activeBundleFilter = (where) => ({ $and: [where, { [DELETION_TOKEN_FIELD]: { $exists: false } }] });
+const createMongoCollections = (client) => {
+	const database = client.db();
+	return {
+		bundles: database.collection("bundles"),
+		bundlePatches: database.collection("bundle_patches"),
+		bundleEvents: database.collection("bundle_events"),
+		channels: database.collection("channels"),
+		apiKeys: database.collection("api_keys"),
+		releases: database.collection("releases"),
+		releaseCatalogs: database.collection("release_catalogs")
+	};
+};
+const mongoSessionOptions = (session) => session === void 0 ? {} : { session };
+//#endregion
+exports.DELETION_TOKEN_FIELD = DELETION_TOKEN_FIELD;
+exports.MongoAdapterConstraintError = MongoAdapterConstraintError;
+exports.WITHOUT_INTERNAL_FIELDS = WITHOUT_INTERNAL_FIELDS;
+exports.WITHOUT_MONGO_ID = WITHOUT_MONGO_ID;
+exports.activeBundleFilter = activeBundleFilter;
+exports.createMongoCollections = createMongoCollections;
+exports.mongoSessionOptions = mongoSessionOptions;

package/dist/adapters/mongodbCollections.mjs

@@ -0,0 +1,30 @@
+//#region src/adapters/mongodbCollections.ts
+var MongoAdapterConstraintError = class extends Error {
+	name = "MongoAdapterConstraintError";
+	constructor(reason) {
+		super(`MongoDB adapter constraint failed: ${reason}`);
+		this.reason = reason;
+	}
+};
+const WITHOUT_MONGO_ID = { _id: 0 };
+const DELETION_TOKEN_FIELD = "_hot_updater_deletion_token";
+const WITHOUT_INTERNAL_FIELDS = {
+	...WITHOUT_MONGO_ID,
+	[DELETION_TOKEN_FIELD]: 0
+};
+const activeBundleFilter = (where) => ({ $and: [where, { [DELETION_TOKEN_FIELD]: { $exists: false } }] });
+const createMongoCollections = (client) => {
+	const database = client.db();
+	return {
+		bundles: database.collection("bundles"),
+		bundlePatches: database.collection("bundle_patches"),
+		bundleEvents: database.collection("bundle_events"),
+		channels: database.collection("channels"),
+		apiKeys: database.collection("api_keys"),
+		releases: database.collection("releases"),
+		releaseCatalogs: database.collection("release_catalogs")
+	};
+};
+const mongoSessionOptions = (session) => session === void 0 ? {} : { session };
+//#endregion
+export { DELETION_TOKEN_FIELD, MongoAdapterConstraintError, WITHOUT_INTERNAL_FIELDS, WITHOUT_MONGO_ID, activeBundleFilter, createMongoCollections, mongoSessionOptions };

package/dist/adapters/mongodbQuery.cjs

@@ -0,0 +1,77 @@
+//#region src/adapters/mongodbQuery.ts
+const escapeRegularExpression = (value) => value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+function literal(value) {
+	return { $literal: value };
+}
+const stringExpression = (field, operator, value, mode) => {
+	const escaped = escapeRegularExpression(value);
+	const regex = operator === "starts_with" ? `^${escaped}` : operator === "ends_with" ? `${escaped}$` : escaped;
+	return { $regexMatch: {
+		input: { $ifNull: [`$${field}`, ""] },
+		regex: literal(regex),
+		...mode === "insensitive" ? { options: "i" } : {}
+	} };
+};
+const predicate = (where) => {
+	const field = `$${where.field}`;
+	switch (where.operator) {
+		case void 0:
+		case "eq": return { $expr: "mode" in where && where.mode === "insensitive" && typeof where.value === "string" ? { $eq: [{ $toLower: { $ifNull: [field, ""] } }, literal(where.value.toLocaleLowerCase())] } : { $eq: [field, literal(where.value)] } };
+		case "ne": {
+			const comparison = "mode" in where && where.mode === "insensitive" ? { $ne: [{ $toLower: { $ifNull: [field, ""] } }, literal(where.value.toLocaleLowerCase())] } : { $ne: [field, literal(where.value)] };
+			return where.value === null ? { $expr: comparison } : { $and: [{ $expr: { $ne: [field, null] } }, { $expr: comparison }] };
+		}
+		case "gt":
+		case "gte":
+		case "lt":
+		case "lte": return { $and: [{ $expr: { $ne: [field, null] } }, { $expr: { [`$${where.operator}`]: [field, literal(where.value)] } }] };
+		case "in": return { $expr: { $in: [field, literal(where.value)] } };
+		case "not_in": return where.value.length === 0 ? { $expr: { $not: [{ $in: [field, literal(where.value)] }] } } : { $and: [{ $expr: { $ne: [field, null] } }, { $expr: { $not: [{ $in: [field, literal(where.value)] }] } }] };
+		case "contains":
+		case "starts_with":
+		case "ends_with": return { $expr: stringExpression(where.field, where.operator, where.value, where.mode) };
+	}
+};
+const createMongoWhereDocument = (where) => {
+	const items = Array.isArray(where) ? where : [];
+	const first = items[0];
+	if (first === void 0) return {};
+	let result = predicate(first);
+	for (const item of items.slice(1)) result = { [item.connector === "OR" ? "$or" : "$and"]: [result, predicate(item)] };
+	return result;
+};
+function createMongoBundleWhere(where) {
+	return createMongoWhereDocument(where);
+}
+function createMongoPatchWhere(where) {
+	return createMongoWhereDocument(where);
+}
+function createMongoEventWhere(where) {
+	return createMongoWhereDocument(where);
+}
+function createMongoApiKeyWhere(where) {
+	return createMongoWhereDocument(where);
+}
+function createMongoChannelWhere(where) {
+	return createMongoWhereDocument(where);
+}
+function createMongoReleaseWhere(where) {
+	return createMongoWhereDocument(where);
+}
+function createMongoReleaseCatalogWhere(where) {
+	return createMongoWhereDocument(where);
+}
+const createMongoSort = (input) => {
+	const clauses = Array.isArray(input) ? input : input && "orderBy" in input && Array.isArray(input.orderBy) ? input.orderBy : void 0;
+	if (clauses === void 0 || clauses.length === 0) return void 0;
+	return Object.fromEntries(clauses.map((clause) => [clause.field, clause.direction === "asc" ? 1 : -1]));
+};
+//#endregion
+exports.createMongoApiKeyWhere = createMongoApiKeyWhere;
+exports.createMongoBundleWhere = createMongoBundleWhere;
+exports.createMongoChannelWhere = createMongoChannelWhere;
+exports.createMongoEventWhere = createMongoEventWhere;
+exports.createMongoPatchWhere = createMongoPatchWhere;
+exports.createMongoReleaseCatalogWhere = createMongoReleaseCatalogWhere;
+exports.createMongoReleaseWhere = createMongoReleaseWhere;
+exports.createMongoSort = createMongoSort;

package/dist/adapters/mongodbQuery.mjs

@@ -0,0 +1,70 @@
+//#region src/adapters/mongodbQuery.ts
+const escapeRegularExpression = (value) => value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+function literal(value) {
+	return { $literal: value };
+}
+const stringExpression = (field, operator, value, mode) => {
+	const escaped = escapeRegularExpression(value);
+	const regex = operator === "starts_with" ? `^${escaped}` : operator === "ends_with" ? `${escaped}$` : escaped;
+	return { $regexMatch: {
+		input: { $ifNull: [`$${field}`, ""] },
+		regex: literal(regex),
+		...mode === "insensitive" ? { options: "i" } : {}
+	} };
+};
+const predicate = (where) => {
+	const field = `$${where.field}`;
+	switch (where.operator) {
+		case void 0:
+		case "eq": return { $expr: "mode" in where && where.mode === "insensitive" && typeof where.value === "string" ? { $eq: [{ $toLower: { $ifNull: [field, ""] } }, literal(where.value.toLocaleLowerCase())] } : { $eq: [field, literal(where.value)] } };
+		case "ne": {
+			const comparison = "mode" in where && where.mode === "insensitive" ? { $ne: [{ $toLower: { $ifNull: [field, ""] } }, literal(where.value.toLocaleLowerCase())] } : { $ne: [field, literal(where.value)] };
+			return where.value === null ? { $expr: comparison } : { $and: [{ $expr: { $ne: [field, null] } }, { $expr: comparison }] };
+		}
+		case "gt":
+		case "gte":
+		case "lt":
+		case "lte": return { $and: [{ $expr: { $ne: [field, null] } }, { $expr: { [`$${where.operator}`]: [field, literal(where.value)] } }] };
+		case "in": return { $expr: { $in: [field, literal(where.value)] } };
+		case "not_in": return where.value.length === 0 ? { $expr: { $not: [{ $in: [field, literal(where.value)] }] } } : { $and: [{ $expr: { $ne: [field, null] } }, { $expr: { $not: [{ $in: [field, literal(where.value)] }] } }] };
+		case "contains":
+		case "starts_with":
+		case "ends_with": return { $expr: stringExpression(where.field, where.operator, where.value, where.mode) };
+	}
+};
+const createMongoWhereDocument = (where) => {
+	const items = Array.isArray(where) ? where : [];
+	const first = items[0];
+	if (first === void 0) return {};
+	let result = predicate(first);
+	for (const item of items.slice(1)) result = { [item.connector === "OR" ? "$or" : "$and"]: [result, predicate(item)] };
+	return result;
+};
+function createMongoBundleWhere(where) {
+	return createMongoWhereDocument(where);
+}
+function createMongoPatchWhere(where) {
+	return createMongoWhereDocument(where);
+}
+function createMongoEventWhere(where) {
+	return createMongoWhereDocument(where);
+}
+function createMongoApiKeyWhere(where) {
+	return createMongoWhereDocument(where);
+}
+function createMongoChannelWhere(where) {
+	return createMongoWhereDocument(where);
+}
+function createMongoReleaseWhere(where) {
+	return createMongoWhereDocument(where);
+}
+function createMongoReleaseCatalogWhere(where) {
+	return createMongoWhereDocument(where);
+}
+const createMongoSort = (input) => {
+	const clauses = Array.isArray(input) ? input : input && "orderBy" in input && Array.isArray(input.orderBy) ? input.orderBy : void 0;
+	if (clauses === void 0 || clauses.length === 0) return void 0;
+	return Object.fromEntries(clauses.map((clause) => [clause.field, clause.direction === "asc" ? 1 : -1]));
+};
+//#endregion
+export { createMongoApiKeyWhere, createMongoBundleWhere, createMongoChannelWhere, createMongoEventWhere, createMongoPatchWhere, createMongoReleaseCatalogWhere, createMongoReleaseWhere, createMongoSort };

package/dist/adapters/mongodbReads.cjs

@@ -0,0 +1,148 @@
+require("../_virtual/_rolldown/runtime.cjs");
+const require_databasePluginUtils = require("./databasePluginUtils.cjs");
+const require_mongodbCollections = require("./mongodbCollections.cjs");
+const require_mongodbQuery = require("./mongodbQuery.cjs");
+let _hot_updater_plugin_core = require("@hot-updater/plugin-core");
+//#region src/adapters/mongodbReads.ts
+const findMongoRows = async (collections, input, session) => {
+	if (input.limit === 0) return [];
+	const rawOrderBy = input.orderBy;
+	const needsInMemoryOrder = require_databasePluginUtils.hasNullOrderOverrides(rawOrderBy);
+	switch (input.model) {
+		case "bundles": {
+			const cursor = collections.bundles.find(require_mongodbCollections.activeBundleFilter(require_mongodbQuery.createMongoBundleWhere(input.where)), {
+				projection: require_mongodbCollections.WITHOUT_INTERNAL_FIELDS,
+				...require_mongodbCollections.mongoSessionOptions(session)
+			}).skip(input.offset).limit(input.limit);
+			if (rawOrderBy === void 0) return cursor.toArray();
+			if (needsInMemoryOrder) return require_databasePluginUtils.sortRowsByOrder(await collections.bundles.find(require_mongodbCollections.activeBundleFilter(require_mongodbQuery.createMongoBundleWhere(input.where)), {
+				projection: require_mongodbCollections.WITHOUT_INTERNAL_FIELDS,
+				...require_mongodbCollections.mongoSessionOptions(session)
+			}).toArray(), rawOrderBy).slice(input.offset, input.offset + input.limit);
+			const sort = require_mongodbQuery.createMongoSort(input);
+			return sort === void 0 ? cursor.toArray() : cursor.sort(sort).toArray();
+		}
+		case "bundle_patches": {
+			const cursor = collections.bundlePatches.find(require_mongodbQuery.createMongoPatchWhere(input.where), {
+				projection: require_mongodbCollections.WITHOUT_MONGO_ID,
+				...require_mongodbCollections.mongoSessionOptions(session)
+			}).skip(input.offset).limit(input.limit);
+			if (rawOrderBy === void 0) return cursor.toArray();
+			if (needsInMemoryOrder) return require_databasePluginUtils.sortRowsByOrder(await collections.bundlePatches.find(require_mongodbQuery.createMongoPatchWhere(input.where), {
+				projection: require_mongodbCollections.WITHOUT_MONGO_ID,
+				...require_mongodbCollections.mongoSessionOptions(session)
+			}).toArray(), rawOrderBy).slice(input.offset, input.offset + input.limit);
+			const sort = require_mongodbQuery.createMongoSort(input);
+			return sort === void 0 ? cursor.toArray() : cursor.sort(sort).toArray();
+		}
+		case "bundle_events": {
+			const cursor = collections.bundleEvents.find(require_mongodbQuery.createMongoEventWhere(input.where), {
+				projection: require_mongodbCollections.WITHOUT_MONGO_ID,
+				...require_mongodbCollections.mongoSessionOptions(session)
+			}).skip(input.offset).limit(input.limit);
+			if (rawOrderBy === void 0) return cursor.toArray();
+			if (needsInMemoryOrder) return require_databasePluginUtils.sortRowsByOrder(await collections.bundleEvents.find(require_mongodbQuery.createMongoEventWhere(input.where), {
+				projection: require_mongodbCollections.WITHOUT_MONGO_ID,
+				...require_mongodbCollections.mongoSessionOptions(session)
+			}).toArray(), rawOrderBy).slice(input.offset, input.offset + input.limit);
+			const sort = require_mongodbQuery.createMongoSort(input);
+			return sort === void 0 ? cursor.toArray() : cursor.sort(sort).toArray();
+		}
+		case "api_keys": {
+			const cursor = collections.apiKeys.find(require_mongodbQuery.createMongoApiKeyWhere(input.where), {
+				projection: require_mongodbCollections.WITHOUT_MONGO_ID,
+				...require_mongodbCollections.mongoSessionOptions(session)
+			}).skip(input.offset).limit(input.limit);
+			if (rawOrderBy === void 0) return cursor.toArray();
+			if (needsInMemoryOrder) return require_databasePluginUtils.sortRowsByOrder(await collections.apiKeys.find(require_mongodbQuery.createMongoApiKeyWhere(input.where), {
+				projection: require_mongodbCollections.WITHOUT_MONGO_ID,
+				...require_mongodbCollections.mongoSessionOptions(session)
+			}).toArray(), rawOrderBy).slice(input.offset, input.offset + input.limit);
+			const sort = require_mongodbQuery.createMongoSort(input);
+			return sort === void 0 ? cursor.toArray() : cursor.sort(sort).toArray();
+		}
+		case "channels": {
+			const cursor = collections.channels.find(require_mongodbQuery.createMongoChannelWhere(input.where), {
+				projection: require_mongodbCollections.WITHOUT_MONGO_ID,
+				...require_mongodbCollections.mongoSessionOptions(session)
+			}).skip(input.offset).limit(input.limit);
+			if (rawOrderBy === void 0) return cursor.toArray();
+			if (needsInMemoryOrder) return require_databasePluginUtils.sortRowsByOrder(await collections.channels.find(require_mongodbQuery.createMongoChannelWhere(input.where), {
+				projection: require_mongodbCollections.WITHOUT_MONGO_ID,
+				...require_mongodbCollections.mongoSessionOptions(session)
+			}).toArray(), rawOrderBy).slice(input.offset, input.offset + input.limit);
+			const sort = require_mongodbQuery.createMongoSort(input);
+			return sort === void 0 ? cursor.toArray() : cursor.sort(sort).toArray();
+		}
+		case "releases": {
+			const cursor = collections.releases.find(require_mongodbQuery.createMongoReleaseWhere(input.where), {
+				projection: require_mongodbCollections.WITHOUT_MONGO_ID,
+				...require_mongodbCollections.mongoSessionOptions(session)
+			}).skip(input.offset).limit(input.limit);
+			if (rawOrderBy === void 0) return cursor.toArray();
+			if (needsInMemoryOrder) return require_databasePluginUtils.sortRowsByOrder(await collections.releases.find(require_mongodbQuery.createMongoReleaseWhere(input.where), {
+				projection: require_mongodbCollections.WITHOUT_MONGO_ID,
+				...require_mongodbCollections.mongoSessionOptions(session)
+			}).toArray(), rawOrderBy).slice(input.offset, input.offset + input.limit);
+			const sort = require_mongodbQuery.createMongoSort(input);
+			return sort === void 0 ? cursor.toArray() : cursor.sort(sort).toArray();
+		}
+		case "release_catalogs": {
+			const cursor = collections.releaseCatalogs.find(require_mongodbQuery.createMongoReleaseCatalogWhere(input.where), {
+				projection: require_mongodbCollections.WITHOUT_MONGO_ID,
+				...require_mongodbCollections.mongoSessionOptions(session)
+			}).skip(input.offset).limit(input.limit);
+			if (rawOrderBy === void 0) return cursor.toArray();
+			if (needsInMemoryOrder) return require_databasePluginUtils.sortRowsByOrder(await collections.releaseCatalogs.find(require_mongodbQuery.createMongoReleaseCatalogWhere(input.where), {
+				projection: require_mongodbCollections.WITHOUT_MONGO_ID,
+				...require_mongodbCollections.mongoSessionOptions(session)
+			}).toArray(), rawOrderBy).slice(input.offset, input.offset + input.limit);
+			const sort = require_mongodbQuery.createMongoSort(input);
+			return sort === void 0 ? cursor.toArray() : cursor.sort(sort).toArray();
+		}
+	}
+};
+const createMongoReads = (collections, session) => ({
+	count: async (input) => {
+		if (input.distinct !== void 0) throw new _hot_updater_plugin_core.DatabasePluginInputError("invalid-operation");
+		switch (input.model) {
+			case "bundles": return collections.bundles.countDocuments(require_mongodbCollections.activeBundleFilter(require_mongodbQuery.createMongoBundleWhere(input.where)), require_mongodbCollections.mongoSessionOptions(session));
+			case "bundle_patches": return collections.bundlePatches.countDocuments(require_mongodbQuery.createMongoPatchWhere(input.where), require_mongodbCollections.mongoSessionOptions(session));
+			case "releases": return collections.releases.countDocuments(require_mongodbQuery.createMongoReleaseWhere(input.where), require_mongodbCollections.mongoSessionOptions(session));
+		}
+	},
+	findOne: async (input) => {
+		switch (input.model) {
+			case "bundles": return collections.bundles.findOne(require_mongodbCollections.activeBundleFilter(require_mongodbQuery.createMongoBundleWhere(input.where)), {
+				projection: require_mongodbCollections.WITHOUT_INTERNAL_FIELDS,
+				...require_mongodbCollections.mongoSessionOptions(session)
+			});
+			case "channels": return collections.channels.findOne(require_mongodbQuery.createMongoChannelWhere(input.where), {
+				projection: require_mongodbCollections.WITHOUT_MONGO_ID,
+				...require_mongodbCollections.mongoSessionOptions(session)
+			});
+			case "api_keys": return collections.apiKeys.findOne(require_mongodbQuery.createMongoApiKeyWhere(input.where), {
+				projection: require_mongodbCollections.WITHOUT_MONGO_ID,
+				...require_mongodbCollections.mongoSessionOptions(session)
+			});
+			case "bundle_patches": return collections.bundlePatches.findOne(require_mongodbQuery.createMongoPatchWhere(input.where), {
+				projection: require_mongodbCollections.WITHOUT_MONGO_ID,
+				...require_mongodbCollections.mongoSessionOptions(session)
+			});
+			case "releases": return collections.releases.findOne(require_mongodbQuery.createMongoReleaseWhere(input.where), {
+				projection: require_mongodbCollections.WITHOUT_MONGO_ID,
+				...require_mongodbCollections.mongoSessionOptions(session)
+			});
+			case "release_catalogs": return collections.releaseCatalogs.findOne(require_mongodbQuery.createMongoReleaseCatalogWhere(input.where), {
+				projection: require_mongodbCollections.WITHOUT_MONGO_ID,
+				...require_mongodbCollections.mongoSessionOptions(session)
+			});
+		}
+	},
+	findMany: (input) => {
+		if (input.distinctOn !== void 0) throw new _hot_updater_plugin_core.DatabasePluginInputError("invalid-operation");
+		return findMongoRows(collections, input, session);
+	}
+});
+//#endregion
+exports.createMongoReads = createMongoReads;