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

package/dist/adapters/mongodbReads.mjs

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

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

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