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

package/dist/adapters/mongodbReads.cjs

@@ -1,148 +0,0 @@
-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;

package/dist/adapters/mongodbReads.mjs

@@ -1,147 +0,0 @@
-import { hasNullOrderOverrides, sortRowsByOrder } from "./databasePluginUtils.mjs";
-import { WITHOUT_INTERNAL_FIELDS, WITHOUT_MONGO_ID, activeBundleFilter, mongoSessionOptions } from "./mongodbCollections.mjs";
-import { createMongoApiKeyWhere, createMongoBundleWhere, createMongoChannelWhere, createMongoEventWhere, createMongoPatchWhere, createMongoReleaseCatalogWhere, createMongoReleaseWhere, createMongoSort } from "./mongodbQuery.mjs";
-import { DatabasePluginInputError } from "@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 = hasNullOrderOverrides(rawOrderBy);
-	switch (input.model) {
-		case "bundles": {
-			const cursor = collections.bundles.find(activeBundleFilter(createMongoBundleWhere(input.where)), {
-				projection: WITHOUT_INTERNAL_FIELDS,
-				...mongoSessionOptions(session)
-			}).skip(input.offset).limit(input.limit);
-			if (rawOrderBy === void 0) return cursor.toArray();
-			if (needsInMemoryOrder) return sortRowsByOrder(await collections.bundles.find(activeBundleFilter(createMongoBundleWhere(input.where)), {
-				projection: WITHOUT_INTERNAL_FIELDS,
-				...mongoSessionOptions(session)
-			}).toArray(), rawOrderBy).slice(input.offset, input.offset + input.limit);
-			const sort = createMongoSort(input);
-			return sort === void 0 ? cursor.toArray() : cursor.sort(sort).toArray();
-		}
-		case "bundle_patches": {
-			const cursor = collections.bundlePatches.find(createMongoPatchWhere(input.where), {
-				projection: WITHOUT_MONGO_ID,
-				...mongoSessionOptions(session)
-			}).skip(input.offset).limit(input.limit);
-			if (rawOrderBy === void 0) return cursor.toArray();
-			if (needsInMemoryOrder) return sortRowsByOrder(await collections.bundlePatches.find(createMongoPatchWhere(input.where), {
-				projection: WITHOUT_MONGO_ID,
-				...mongoSessionOptions(session)
-			}).toArray(), rawOrderBy).slice(input.offset, input.offset + input.limit);
-			const sort = createMongoSort(input);
-			return sort === void 0 ? cursor.toArray() : cursor.sort(sort).toArray();
-		}
-		case "bundle_events": {
-			const cursor = collections.bundleEvents.find(createMongoEventWhere(input.where), {
-				projection: WITHOUT_MONGO_ID,
-				...mongoSessionOptions(session)
-			}).skip(input.offset).limit(input.limit);
-			if (rawOrderBy === void 0) return cursor.toArray();
-			if (needsInMemoryOrder) return sortRowsByOrder(await collections.bundleEvents.find(createMongoEventWhere(input.where), {
-				projection: WITHOUT_MONGO_ID,
-				...mongoSessionOptions(session)
-			}).toArray(), rawOrderBy).slice(input.offset, input.offset + input.limit);
-			const sort = createMongoSort(input);
-			return sort === void 0 ? cursor.toArray() : cursor.sort(sort).toArray();
-		}
-		case "api_keys": {
-			const cursor = collections.apiKeys.find(createMongoApiKeyWhere(input.where), {
-				projection: WITHOUT_MONGO_ID,
-				...mongoSessionOptions(session)
-			}).skip(input.offset).limit(input.limit);
-			if (rawOrderBy === void 0) return cursor.toArray();
-			if (needsInMemoryOrder) return sortRowsByOrder(await collections.apiKeys.find(createMongoApiKeyWhere(input.where), {
-				projection: WITHOUT_MONGO_ID,
-				...mongoSessionOptions(session)
-			}).toArray(), rawOrderBy).slice(input.offset, input.offset + input.limit);
-			const sort = createMongoSort(input);
-			return sort === void 0 ? cursor.toArray() : cursor.sort(sort).toArray();
-		}
-		case "channels": {
-			const cursor = collections.channels.find(createMongoChannelWhere(input.where), {
-				projection: WITHOUT_MONGO_ID,
-				...mongoSessionOptions(session)
-			}).skip(input.offset).limit(input.limit);
-			if (rawOrderBy === void 0) return cursor.toArray();
-			if (needsInMemoryOrder) return sortRowsByOrder(await collections.channels.find(createMongoChannelWhere(input.where), {
-				projection: WITHOUT_MONGO_ID,
-				...mongoSessionOptions(session)
-			}).toArray(), rawOrderBy).slice(input.offset, input.offset + input.limit);
-			const sort = createMongoSort(input);
-			return sort === void 0 ? cursor.toArray() : cursor.sort(sort).toArray();
-		}
-		case "releases": {
-			const cursor = collections.releases.find(createMongoReleaseWhere(input.where), {
-				projection: WITHOUT_MONGO_ID,
-				...mongoSessionOptions(session)
-			}).skip(input.offset).limit(input.limit);
-			if (rawOrderBy === void 0) return cursor.toArray();
-			if (needsInMemoryOrder) return sortRowsByOrder(await collections.releases.find(createMongoReleaseWhere(input.where), {
-				projection: WITHOUT_MONGO_ID,
-				...mongoSessionOptions(session)
-			}).toArray(), rawOrderBy).slice(input.offset, input.offset + input.limit);
-			const sort = createMongoSort(input);
-			return sort === void 0 ? cursor.toArray() : cursor.sort(sort).toArray();
-		}
-		case "release_catalogs": {
-			const cursor = collections.releaseCatalogs.find(createMongoReleaseCatalogWhere(input.where), {
-				projection: WITHOUT_MONGO_ID,
-				...mongoSessionOptions(session)
-			}).skip(input.offset).limit(input.limit);
-			if (rawOrderBy === void 0) return cursor.toArray();
-			if (needsInMemoryOrder) return sortRowsByOrder(await collections.releaseCatalogs.find(createMongoReleaseCatalogWhere(input.where), {
-				projection: WITHOUT_MONGO_ID,
-				...mongoSessionOptions(session)
-			}).toArray(), rawOrderBy).slice(input.offset, input.offset + input.limit);
-			const sort = 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 DatabasePluginInputError("invalid-operation");
-		switch (input.model) {
-			case "bundles": return collections.bundles.countDocuments(activeBundleFilter(createMongoBundleWhere(input.where)), mongoSessionOptions(session));
-			case "bundle_patches": return collections.bundlePatches.countDocuments(createMongoPatchWhere(input.where), mongoSessionOptions(session));
-			case "releases": return collections.releases.countDocuments(createMongoReleaseWhere(input.where), mongoSessionOptions(session));
-		}
-	},
-	findOne: async (input) => {
-		switch (input.model) {
-			case "bundles": return collections.bundles.findOne(activeBundleFilter(createMongoBundleWhere(input.where)), {
-				projection: WITHOUT_INTERNAL_FIELDS,
-				...mongoSessionOptions(session)
-			});
-			case "channels": return collections.channels.findOne(createMongoChannelWhere(input.where), {
-				projection: WITHOUT_MONGO_ID,
-				...mongoSessionOptions(session)
-			});
-			case "api_keys": return collections.apiKeys.findOne(createMongoApiKeyWhere(input.where), {
-				projection: WITHOUT_MONGO_ID,
-				...mongoSessionOptions(session)
-			});
-			case "bundle_patches": return collections.bundlePatches.findOne(createMongoPatchWhere(input.where), {
-				projection: WITHOUT_MONGO_ID,
-				...mongoSessionOptions(session)
-			});
-			case "releases": return collections.releases.findOne(createMongoReleaseWhere(input.where), {
-				projection: WITHOUT_MONGO_ID,
-				...mongoSessionOptions(session)
-			});
-			case "release_catalogs": return collections.releaseCatalogs.findOne(createMongoReleaseCatalogWhere(input.where), {
-				projection: WITHOUT_MONGO_ID,
-				...mongoSessionOptions(session)
-			});
-		}
-	},
-	findMany: (input) => {
-		if (input.distinctOn !== void 0) throw new DatabasePluginInputError("invalid-operation");
-		return findMongoRows(collections, input, session);
-	}
-});
-//#endregion
-export { createMongoReads };

package/dist/adapters/mongodbWrites.cjs

@@ -1,134 +0,0 @@
-require("../_virtual/_rolldown/runtime.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/mongodbWrites.ts
-const assertPatchReferences = async (bundles, patch, session) => {
-	const ids = Array.from(new Set([patch.bundle_id, patch.base_bundle_id]));
-	if (await bundles.countDocuments(require_mongodbCollections.activeBundleFilter({ id: { $in: ids } }), require_mongodbCollections.mongoSessionOptions(session)) !== ids.length) throw new require_mongodbCollections.MongoAdapterConstraintError(`patch "${patch.id}" references a missing bundle`);
-};
-const createMongoWrites = (collections, session) => ({
-	deleteChannel: async ({ id }) => {
-		if (session === void 0) throw new require_mongodbCollections.MongoAdapterConstraintError("channel deletion requires transaction support");
-		if ((await collections.channels.updateOne({ id }, { $set: { id } }, require_mongodbCollections.mongoSessionOptions(session))).matchedCount !== 1) return {
-			deleted: false,
-			reason: "not_found"
-		};
-		if (await collections.releases.countDocuments({ channel_id: id }, require_mongodbCollections.mongoSessionOptions(session)) > 0) return {
-			deleted: false,
-			reason: "not_empty"
-		};
-		await collections.channels.deleteMany({ id }, require_mongodbCollections.mongoSessionOptions(session));
-		return { deleted: true };
-	},
-	insertChannel: async (input) => {
-		const result = await collections.channels.updateOne({ name: input.row.name }, { $setOnInsert: input.row }, {
-			upsert: true,
-			...require_mongodbCollections.mongoSessionOptions(session)
-		});
-		const row = await collections.channels.findOne({ name: input.row.name }, require_mongodbCollections.mongoSessionOptions(session));
-		if (row === null) throw new require_mongodbCollections.MongoAdapterConstraintError("channels.insert.return-existing");
-		return {
-			row,
-			inserted: result.upsertedCount === 1
-		};
-	},
-	create: async (input) => {
-		switch (input.model) {
-			case "bundles":
-				await collections.bundles.insertOne(input.data, require_mongodbCollections.mongoSessionOptions(session));
-				return input.data;
-			case "bundle_patches":
-				await assertPatchReferences(collections.bundles, input.data, session);
-				await collections.bundlePatches.insertOne(input.data, require_mongodbCollections.mongoSessionOptions(session));
-				try {
-					await assertPatchReferences(collections.bundles, input.data, session);
-				} catch (error) {
-					await collections.bundlePatches.deleteMany({ id: input.data.id }, require_mongodbCollections.mongoSessionOptions(session));
-					throw error;
-				}
-				return input.data;
-			case "bundle_events":
-				await collections.bundleEvents.insertOne(input.data, require_mongodbCollections.mongoSessionOptions(session));
-				return input.data;
-			case "releases":
-				await collections.releases.insertOne(input.data, require_mongodbCollections.mongoSessionOptions(session));
-				return input.data;
-			case "release_catalogs":
-				await collections.releaseCatalogs.insertOne(input.data, require_mongodbCollections.mongoSessionOptions(session));
-				return input.data;
-			case "api_keys":
-				if (input.onConflict === "ignore") {
-					await collections.apiKeys.updateOne({ hash: input.data.hash }, { $setOnInsert: input.data }, {
-						upsert: true,
-						...require_mongodbCollections.mongoSessionOptions(session)
-					});
-					return input.data;
-				}
-				await collections.apiKeys.insertOne(input.data, require_mongodbCollections.mongoSessionOptions(session));
-				return input.data;
-			case "channels":
-				if (input.onConflict === "ignore") {
-					await collections.channels.updateOne({ name: input.data.name }, { $setOnInsert: input.data }, {
-						upsert: true,
-						...require_mongodbCollections.mongoSessionOptions(session)
-					});
-					return input.data;
-				}
-				await collections.channels.insertOne(input.data, require_mongodbCollections.mongoSessionOptions(session));
-				return input.data;
-		}
-	},
-	update: async (input) => {
-		if (input.model === "api_keys") return collections.apiKeys.findOneAndUpdate(require_mongodbQuery.createMongoApiKeyWhere(input.where), { $set: input.update }, {
-			projection: require_mongodbCollections.WITHOUT_INTERNAL_FIELDS,
-			returnDocument: "after",
-			...require_mongodbCollections.mongoSessionOptions(session)
-		});
-		if (input.model === "releases") return collections.releases.findOneAndUpdate(require_mongodbQuery.createMongoReleaseWhere(input.where), { $set: input.update }, {
-			projection: require_mongodbCollections.WITHOUT_INTERNAL_FIELDS,
-			returnDocument: "after",
-			...require_mongodbCollections.mongoSessionOptions(session)
-		});
-		if (input.model === "release_catalogs") return collections.releaseCatalogs.findOneAndUpdate(require_mongodbQuery.createMongoReleaseCatalogWhere(input.where), { $set: input.update }, {
-			projection: require_mongodbCollections.WITHOUT_INTERNAL_FIELDS,
-			returnDocument: "after",
-			...require_mongodbCollections.mongoSessionOptions(session)
-		});
-		return collections.bundles.findOneAndUpdate(require_mongodbCollections.activeBundleFilter(require_mongodbQuery.createMongoBundleWhere(input.where)), { $set: input.update }, {
-			projection: require_mongodbCollections.WITHOUT_INTERNAL_FIELDS,
-			returnDocument: "after",
-			...require_mongodbCollections.mongoSessionOptions(session)
-		});
-	},
-	delete: async (input) => {
-		switch (input.model) {
-			case "bundle_patches":
-				await collections.bundlePatches.deleteMany(require_mongodbQuery.createMongoPatchWhere(input.where), require_mongodbCollections.mongoSessionOptions(session));
-				return;
-			case "bundles": {
-				const deletionToken = (0, _hot_updater_plugin_core.createUUIDv7)();
-				await collections.bundles.updateMany(require_mongodbQuery.createMongoBundleWhere(input.where), { $set: { [require_mongodbCollections.DELETION_TOKEN_FIELD]: deletionToken } }, require_mongodbCollections.mongoSessionOptions(session));
-				const ids = (await collections.bundles.find({ [require_mongodbCollections.DELETION_TOKEN_FIELD]: deletionToken }, {
-					projection: {
-						_id: 0,
-						id: 1
-					},
-					...require_mongodbCollections.mongoSessionOptions(session)
-				}).toArray()).map(({ id }) => id);
-				if (ids.length === 0) return;
-				await collections.bundlePatches.deleteMany({ $or: [{ bundle_id: { $in: ids } }, { base_bundle_id: { $in: ids } }] }, require_mongodbCollections.mongoSessionOptions(session));
-				await collections.bundles.deleteMany({ [require_mongodbCollections.DELETION_TOKEN_FIELD]: deletionToken }, require_mongodbCollections.mongoSessionOptions(session));
-				return;
-			}
-			case "releases":
-				await collections.releases.deleteMany(require_mongodbQuery.createMongoReleaseWhere(input.where), require_mongodbCollections.mongoSessionOptions(session));
-				return;
-			case "channels":
-				await collections.channels.deleteMany(require_mongodbQuery.createMongoChannelWhere(input.where), require_mongodbCollections.mongoSessionOptions(session));
-				return;
-		}
-	}
-});
-//#endregion
-exports.createMongoWrites = createMongoWrites;

package/dist/adapters/mongodbWrites.mjs

@@ -1,133 +0,0 @@
-import { DELETION_TOKEN_FIELD, MongoAdapterConstraintError, WITHOUT_INTERNAL_FIELDS, activeBundleFilter, mongoSessionOptions } from "./mongodbCollections.mjs";
-import { createMongoApiKeyWhere, createMongoBundleWhere, createMongoChannelWhere, createMongoPatchWhere, createMongoReleaseCatalogWhere, createMongoReleaseWhere } from "./mongodbQuery.mjs";
-import { createUUIDv7 } from "@hot-updater/plugin-core";
-//#region src/adapters/mongodbWrites.ts
-const assertPatchReferences = async (bundles, patch, session) => {
-	const ids = Array.from(new Set([patch.bundle_id, patch.base_bundle_id]));
-	if (await bundles.countDocuments(activeBundleFilter({ id: { $in: ids } }), mongoSessionOptions(session)) !== ids.length) throw new MongoAdapterConstraintError(`patch "${patch.id}" references a missing bundle`);
-};
-const createMongoWrites = (collections, session) => ({
-	deleteChannel: async ({ id }) => {
-		if (session === void 0) throw new MongoAdapterConstraintError("channel deletion requires transaction support");
-		if ((await collections.channels.updateOne({ id }, { $set: { id } }, mongoSessionOptions(session))).matchedCount !== 1) return {
-			deleted: false,
-			reason: "not_found"
-		};
-		if (await collections.releases.countDocuments({ channel_id: id }, mongoSessionOptions(session)) > 0) return {
-			deleted: false,
-			reason: "not_empty"
-		};
-		await collections.channels.deleteMany({ id }, mongoSessionOptions(session));
-		return { deleted: true };
-	},
-	insertChannel: async (input) => {
-		const result = await collections.channels.updateOne({ name: input.row.name }, { $setOnInsert: input.row }, {
-			upsert: true,
-			...mongoSessionOptions(session)
-		});
-		const row = await collections.channels.findOne({ name: input.row.name }, mongoSessionOptions(session));
-		if (row === null) throw new MongoAdapterConstraintError("channels.insert.return-existing");
-		return {
-			row,
-			inserted: result.upsertedCount === 1
-		};
-	},
-	create: async (input) => {
-		switch (input.model) {
-			case "bundles":
-				await collections.bundles.insertOne(input.data, mongoSessionOptions(session));
-				return input.data;
-			case "bundle_patches":
-				await assertPatchReferences(collections.bundles, input.data, session);
-				await collections.bundlePatches.insertOne(input.data, mongoSessionOptions(session));
-				try {
-					await assertPatchReferences(collections.bundles, input.data, session);
-				} catch (error) {
-					await collections.bundlePatches.deleteMany({ id: input.data.id }, mongoSessionOptions(session));
-					throw error;
-				}
-				return input.data;
-			case "bundle_events":
-				await collections.bundleEvents.insertOne(input.data, mongoSessionOptions(session));
-				return input.data;
-			case "releases":
-				await collections.releases.insertOne(input.data, mongoSessionOptions(session));
-				return input.data;
-			case "release_catalogs":
-				await collections.releaseCatalogs.insertOne(input.data, mongoSessionOptions(session));
-				return input.data;
-			case "api_keys":
-				if (input.onConflict === "ignore") {
-					await collections.apiKeys.updateOne({ hash: input.data.hash }, { $setOnInsert: input.data }, {
-						upsert: true,
-						...mongoSessionOptions(session)
-					});
-					return input.data;
-				}
-				await collections.apiKeys.insertOne(input.data, mongoSessionOptions(session));
-				return input.data;
-			case "channels":
-				if (input.onConflict === "ignore") {
-					await collections.channels.updateOne({ name: input.data.name }, { $setOnInsert: input.data }, {
-						upsert: true,
-						...mongoSessionOptions(session)
-					});
-					return input.data;
-				}
-				await collections.channels.insertOne(input.data, mongoSessionOptions(session));
-				return input.data;
-		}
-	},
-	update: async (input) => {
-		if (input.model === "api_keys") return collections.apiKeys.findOneAndUpdate(createMongoApiKeyWhere(input.where), { $set: input.update }, {
-			projection: WITHOUT_INTERNAL_FIELDS,
-			returnDocument: "after",
-			...mongoSessionOptions(session)
-		});
-		if (input.model === "releases") return collections.releases.findOneAndUpdate(createMongoReleaseWhere(input.where), { $set: input.update }, {
-			projection: WITHOUT_INTERNAL_FIELDS,
-			returnDocument: "after",
-			...mongoSessionOptions(session)
-		});
-		if (input.model === "release_catalogs") return collections.releaseCatalogs.findOneAndUpdate(createMongoReleaseCatalogWhere(input.where), { $set: input.update }, {
-			projection: WITHOUT_INTERNAL_FIELDS,
-			returnDocument: "after",
-			...mongoSessionOptions(session)
-		});
-		return collections.bundles.findOneAndUpdate(activeBundleFilter(createMongoBundleWhere(input.where)), { $set: input.update }, {
-			projection: WITHOUT_INTERNAL_FIELDS,
-			returnDocument: "after",
-			...mongoSessionOptions(session)
-		});
-	},
-	delete: async (input) => {
-		switch (input.model) {
-			case "bundle_patches":
-				await collections.bundlePatches.deleteMany(createMongoPatchWhere(input.where), mongoSessionOptions(session));
-				return;
-			case "bundles": {
-				const deletionToken = createUUIDv7();
-				await collections.bundles.updateMany(createMongoBundleWhere(input.where), { $set: { [DELETION_TOKEN_FIELD]: deletionToken } }, mongoSessionOptions(session));
-				const ids = (await collections.bundles.find({ [DELETION_TOKEN_FIELD]: deletionToken }, {
-					projection: {
-						_id: 0,
-						id: 1
-					},
-					...mongoSessionOptions(session)
-				}).toArray()).map(({ id }) => id);
-				if (ids.length === 0) return;
-				await collections.bundlePatches.deleteMany({ $or: [{ bundle_id: { $in: ids } }, { base_bundle_id: { $in: ids } }] }, mongoSessionOptions(session));
-				await collections.bundles.deleteMany({ [DELETION_TOKEN_FIELD]: deletionToken }, mongoSessionOptions(session));
-				return;
-			}
-			case "releases":
-				await collections.releases.deleteMany(createMongoReleaseWhere(input.where), mongoSessionOptions(session));
-				return;
-			case "channels":
-				await collections.channels.deleteMany(createMongoChannelWhere(input.where), mongoSessionOptions(session));
-				return;
-		}
-	}
-});
-//#endregion
-export { createMongoWrites };

package/dist/adapters/prismaQuery.cjs

@@ -1,58 +0,0 @@
-require("../_virtual/_rolldown/runtime.cjs");
-let _hot_updater_plugin_core = require("@hot-updater/plugin-core");
-//#region src/adapters/prismaQuery.ts
-const stringFilter = (operator, value, mode) => {
-	return {
-		[operator === "starts_with" ? "startsWith" : operator === "ends_with" ? "endsWith" : "contains"]: value,
-		...mode ? { mode } : {}
-	};
-};
-const SQL_PATTERN_METACHARACTERS = /[%_\\]/u;
-const MONGODB_PATTERN_METACHARACTERS = /[.*+?^${}()|[\]\\]/u;
-const prismaMode = (mode, provider) => {
-	if (mode === "insensitive" || mode === "sensitive" && provider !== "postgresql") throw new _hot_updater_plugin_core.DatabasePluginInputError("invalid-operation");
-	return mode === "sensitive" ? "default" : void 0;
-};
-const assertLiteralPattern = (value, provider) => {
-	if ((provider === "mongodb" ? MONGODB_PATTERN_METACHARACTERS : SQL_PATTERN_METACHARACTERS).test(value)) throw new _hot_updater_plugin_core.DatabasePluginInputError("invalid-operation");
-};
-const predicate = (where, provider) => {
-	const mode = prismaMode("mode" in where ? where.mode : void 0, provider);
-	switch (where.operator) {
-		case void 0:
-		case "eq": return { [where.field]: mode ? {
-			equals: where.value,
-			mode
-		} : where.value };
-		case "ne": return { [where.field]: {
-			not: where.value,
-			...mode ? { mode } : {}
-		} };
-		case "gt":
-		case "gte":
-		case "lt":
-		case "lte": return { [where.field]: { [where.operator]: where.value } };
-		case "in": return { [where.field]: { in: where.value } };
-		case "not_in": return { [where.field]: { notIn: where.value } };
-		case "contains":
-		case "starts_with":
-		case "ends_with":
-			assertLiteralPattern(where.value, provider);
-			return { [where.field]: stringFilter(where.operator, where.value, mode) };
-	}
-};
-const createPrismaWhere = (where, provider) => {
-	const items = where ?? [];
-	const first = items[0];
-	if (first === void 0) return {};
-	let result = predicate(first, provider);
-	for (const item of items.slice(1)) result = { [item.connector === "OR" ? "OR" : "AND"]: [result, predicate(item, provider)] };
-	return result;
-};
-const createPrismaOrderBy = (orderBy) => {
-	if (orderBy === void 0) return void 0;
-	return (Array.isArray(orderBy) ? orderBy : [orderBy]).map((clause) => ({ [clause.field]: clause.direction }));
-};
-//#endregion
-exports.createPrismaOrderBy = createPrismaOrderBy;
-exports.createPrismaWhere = createPrismaWhere;