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

package/dist/adapters/mongodbReads.cjs

@@ -1,4 +1,3 @@
-require("../_virtual/_rolldown/runtime.cjs");
 const require_databasePluginUtils = require("./databasePluginUtils.cjs");
 const require_mongodbCollections = require("./mongodbCollections.cjs");
 const require_mongodbQuery = require("./mongodbQuery.cjs");
@@ -15,10 +14,13 @@ const findMongoRows = async (collections, input, session) => {
 				...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);
+			if (needsInMemoryOrder) {
+				const rows = await collections.bundles.find(require_mongodbCollections.activeBundleFilter(require_mongodbQuery.createMongoBundleWhere(input.where)), {
+					projection: require_mongodbCollections.WITHOUT_INTERNAL_FIELDS,
+					...require_mongodbCollections.mongoSessionOptions(session)
+				}).toArray();
+				return require_databasePluginUtils.sortRowsByOrder(rows, rawOrderBy).slice(input.offset, input.offset + input.limit);
+			}
 			const sort = require_mongodbQuery.createMongoSort(input);
 			return sort === void 0 ? cursor.toArray() : cursor.sort(sort).toArray();
 		}
@@ -28,23 +30,53 @@ const findMongoRows = async (collections, input, session) => {
 				...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);
+			if (needsInMemoryOrder) {
+				const rows = await collections.bundlePatches.find(require_mongodbQuery.createMongoPatchWhere(input.where), {
+					projection: require_mongodbCollections.WITHOUT_MONGO_ID,
+					...require_mongodbCollections.mongoSessionOptions(session)
+				}).toArray();
+				return require_databasePluginUtils.sortRowsByOrder(rows, 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)
+				...require_mongodbCollections.mongoSessionOptions(session),
+				collation: { locale: "simple" },
+				readPreference: "primary"
 			}).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), {
+			if (needsInMemoryOrder) {
+				const rows = await collections.bundleEvents.find(require_mongodbQuery.createMongoEventWhere(input.where), {
+					projection: require_mongodbCollections.WITHOUT_MONGO_ID,
+					...require_mongodbCollections.mongoSessionOptions(session),
+					collation: { locale: "simple" },
+					readPreference: "primary"
+				}).toArray();
+				return require_databasePluginUtils.sortRowsByOrder(rows, 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_installations": {
+			const cursor = collections.bundleInstallations.find(require_mongodbQuery.createMongoInstallationWhere(input.where), {
 				projection: require_mongodbCollections.WITHOUT_MONGO_ID,
-				...require_mongodbCollections.mongoSessionOptions(session)
-			}).toArray(), rawOrderBy).slice(input.offset, input.offset + input.limit);
+				...require_mongodbCollections.mongoSessionOptions(session),
+				collation: { locale: "simple" },
+				readPreference: "primary"
+			}).skip(input.offset).limit(input.limit);
+			if (rawOrderBy === void 0) return cursor.toArray();
+			if (needsInMemoryOrder) {
+				const rows = await collections.bundleInstallations.find(require_mongodbQuery.createMongoInstallationWhere(input.where), {
+					projection: require_mongodbCollections.WITHOUT_MONGO_ID,
+					...require_mongodbCollections.mongoSessionOptions(session),
+					collation: { locale: "simple" },
+					readPreference: "primary"
+				}).toArray();
+				return require_databasePluginUtils.sortRowsByOrder(rows, rawOrderBy).slice(input.offset, input.offset + input.limit);
+			}
 			const sort = require_mongodbQuery.createMongoSort(input);
 			return sort === void 0 ? cursor.toArray() : cursor.sort(sort).toArray();
 		}
@@ -54,10 +86,13 @@ const findMongoRows = async (collections, input, session) => {
 				...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);
+			if (needsInMemoryOrder) {
+				const rows = await collections.apiKeys.find(require_mongodbQuery.createMongoApiKeyWhere(input.where), {
+					projection: require_mongodbCollections.WITHOUT_MONGO_ID,
+					...require_mongodbCollections.mongoSessionOptions(session)
+				}).toArray();
+				return require_databasePluginUtils.sortRowsByOrder(rows, rawOrderBy).slice(input.offset, input.offset + input.limit);
+			}
 			const sort = require_mongodbQuery.createMongoSort(input);
 			return sort === void 0 ? cursor.toArray() : cursor.sort(sort).toArray();
 		}
@@ -67,10 +102,13 @@ const findMongoRows = async (collections, input, session) => {
 				...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);
+			if (needsInMemoryOrder) {
+				const rows = await collections.channels.find(require_mongodbQuery.createMongoChannelWhere(input.where), {
+					projection: require_mongodbCollections.WITHOUT_MONGO_ID,
+					...require_mongodbCollections.mongoSessionOptions(session)
+				}).toArray();
+				return require_databasePluginUtils.sortRowsByOrder(rows, rawOrderBy).slice(input.offset, input.offset + input.limit);
+			}
 			const sort = require_mongodbQuery.createMongoSort(input);
 			return sort === void 0 ? cursor.toArray() : cursor.sort(sort).toArray();
 		}
@@ -80,10 +118,13 @@ const findMongoRows = async (collections, input, session) => {
 				...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);
+			if (needsInMemoryOrder) {
+				const rows = await collections.releases.find(require_mongodbQuery.createMongoReleaseWhere(input.where), {
+					projection: require_mongodbCollections.WITHOUT_MONGO_ID,
+					...require_mongodbCollections.mongoSessionOptions(session)
+				}).toArray();
+				return require_databasePluginUtils.sortRowsByOrder(rows, rawOrderBy).slice(input.offset, input.offset + input.limit);
+			}
 			const sort = require_mongodbQuery.createMongoSort(input);
 			return sort === void 0 ? cursor.toArray() : cursor.sort(sort).toArray();
 		}
@@ -93,10 +134,13 @@ const findMongoRows = async (collections, input, session) => {
 				...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);
+			if (needsInMemoryOrder) {
+				const rows = await collections.releaseCatalogs.find(require_mongodbQuery.createMongoReleaseCatalogWhere(input.where), {
+					projection: require_mongodbCollections.WITHOUT_MONGO_ID,
+					...require_mongodbCollections.mongoSessionOptions(session)
+				}).toArray();
+				return require_databasePluginUtils.sortRowsByOrder(rows, rawOrderBy).slice(input.offset, input.offset + input.limit);
+			}
 			const sort = require_mongodbQuery.createMongoSort(input);
 			return sort === void 0 ? cursor.toArray() : cursor.sort(sort).toArray();
 		}
@@ -109,6 +153,18 @@ const createMongoReads = (collections, session) => ({
 			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));
+			case "bundle_installations": return collections.bundleInstallations.countDocuments(require_mongodbQuery.createMongoInstallationWhere(input.where), {
+				...require_mongodbCollections.mongoSessionOptions(session),
+				collation: { locale: "simple" },
+				readPreference: "primary",
+				...session === void 0 ? { readConcern: { level: "snapshot" } } : {}
+			});
+			case "bundle_events": return collections.bundleEvents.countDocuments(require_mongodbQuery.createMongoEventWhere(input.where), {
+				...require_mongodbCollections.mongoSessionOptions(session),
+				collation: { locale: "simple" },
+				readPreference: "primary",
+				...session === void 0 ? { readConcern: { level: "snapshot" } } : {}
+			});
 		}
 	},
 	findOne: async (input) => {
@@ -137,6 +193,12 @@ const createMongoReads = (collections, session) => ({
 				projection: require_mongodbCollections.WITHOUT_MONGO_ID,
 				...require_mongodbCollections.mongoSessionOptions(session)
 			});
+			case "bundle_installations": return collections.bundleInstallations.findOne(require_mongodbQuery.createMongoInstallationWhere(input.where), {
+				projection: require_mongodbCollections.WITHOUT_MONGO_ID,
+				...require_mongodbCollections.mongoSessionOptions(session),
+				collation: { locale: "simple" },
+				readPreference: "primary"
+			});
 		}
 	},
 	findMany: (input) => {

package/dist/adapters/mongodbReads.mjs

@@ -1,6 +1,6 @@
 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 { createMongoApiKeyWhere, createMongoBundleWhere, createMongoChannelWhere, createMongoEventWhere, createMongoInstallationWhere, 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) => {
@@ -14,10 +14,13 @@ const findMongoRows = async (collections, input, session) => {
 				...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);
+			if (needsInMemoryOrder) {
+				const rows = await collections.bundles.find(activeBundleFilter(createMongoBundleWhere(input.where)), {
+					projection: WITHOUT_INTERNAL_FIELDS,
+					...mongoSessionOptions(session)
+				}).toArray();
+				return sortRowsByOrder(rows, rawOrderBy).slice(input.offset, input.offset + input.limit);
+			}
 			const sort = createMongoSort(input);
 			return sort === void 0 ? cursor.toArray() : cursor.sort(sort).toArray();
 		}
@@ -27,23 +30,53 @@ const findMongoRows = async (collections, input, session) => {
 				...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);
+			if (needsInMemoryOrder) {
+				const rows = await collections.bundlePatches.find(createMongoPatchWhere(input.where), {
+					projection: WITHOUT_MONGO_ID,
+					...mongoSessionOptions(session)
+				}).toArray();
+				return sortRowsByOrder(rows, 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)
+				...mongoSessionOptions(session),
+				collation: { locale: "simple" },
+				readPreference: "primary"
 			}).skip(input.offset).limit(input.limit);
 			if (rawOrderBy === void 0) return cursor.toArray();
-			if (needsInMemoryOrder) return sortRowsByOrder(await collections.bundleEvents.find(createMongoEventWhere(input.where), {
+			if (needsInMemoryOrder) {
+				const rows = await collections.bundleEvents.find(createMongoEventWhere(input.where), {
+					projection: WITHOUT_MONGO_ID,
+					...mongoSessionOptions(session),
+					collation: { locale: "simple" },
+					readPreference: "primary"
+				}).toArray();
+				return sortRowsByOrder(rows, rawOrderBy).slice(input.offset, input.offset + input.limit);
+			}
+			const sort = createMongoSort(input);
+			return sort === void 0 ? cursor.toArray() : cursor.sort(sort).toArray();
+		}
+		case "bundle_installations": {
+			const cursor = collections.bundleInstallations.find(createMongoInstallationWhere(input.where), {
 				projection: WITHOUT_MONGO_ID,
-				...mongoSessionOptions(session)
-			}).toArray(), rawOrderBy).slice(input.offset, input.offset + input.limit);
+				...mongoSessionOptions(session),
+				collation: { locale: "simple" },
+				readPreference: "primary"
+			}).skip(input.offset).limit(input.limit);
+			if (rawOrderBy === void 0) return cursor.toArray();
+			if (needsInMemoryOrder) {
+				const rows = await collections.bundleInstallations.find(createMongoInstallationWhere(input.where), {
+					projection: WITHOUT_MONGO_ID,
+					...mongoSessionOptions(session),
+					collation: { locale: "simple" },
+					readPreference: "primary"
+				}).toArray();
+				return sortRowsByOrder(rows, rawOrderBy).slice(input.offset, input.offset + input.limit);
+			}
 			const sort = createMongoSort(input);
 			return sort === void 0 ? cursor.toArray() : cursor.sort(sort).toArray();
 		}
@@ -53,10 +86,13 @@ const findMongoRows = async (collections, input, session) => {
 				...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);
+			if (needsInMemoryOrder) {
+				const rows = await collections.apiKeys.find(createMongoApiKeyWhere(input.where), {
+					projection: WITHOUT_MONGO_ID,
+					...mongoSessionOptions(session)
+				}).toArray();
+				return sortRowsByOrder(rows, rawOrderBy).slice(input.offset, input.offset + input.limit);
+			}
 			const sort = createMongoSort(input);
 			return sort === void 0 ? cursor.toArray() : cursor.sort(sort).toArray();
 		}
@@ -66,10 +102,13 @@ const findMongoRows = async (collections, input, session) => {
 				...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);
+			if (needsInMemoryOrder) {
+				const rows = await collections.channels.find(createMongoChannelWhere(input.where), {
+					projection: WITHOUT_MONGO_ID,
+					...mongoSessionOptions(session)
+				}).toArray();
+				return sortRowsByOrder(rows, rawOrderBy).slice(input.offset, input.offset + input.limit);
+			}
 			const sort = createMongoSort(input);
 			return sort === void 0 ? cursor.toArray() : cursor.sort(sort).toArray();
 		}
@@ -79,10 +118,13 @@ const findMongoRows = async (collections, input, session) => {
 				...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);
+			if (needsInMemoryOrder) {
+				const rows = await collections.releases.find(createMongoReleaseWhere(input.where), {
+					projection: WITHOUT_MONGO_ID,
+					...mongoSessionOptions(session)
+				}).toArray();
+				return sortRowsByOrder(rows, rawOrderBy).slice(input.offset, input.offset + input.limit);
+			}
 			const sort = createMongoSort(input);
 			return sort === void 0 ? cursor.toArray() : cursor.sort(sort).toArray();
 		}
@@ -92,10 +134,13 @@ const findMongoRows = async (collections, input, session) => {
 				...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);
+			if (needsInMemoryOrder) {
+				const rows = await collections.releaseCatalogs.find(createMongoReleaseCatalogWhere(input.where), {
+					projection: WITHOUT_MONGO_ID,
+					...mongoSessionOptions(session)
+				}).toArray();
+				return sortRowsByOrder(rows, rawOrderBy).slice(input.offset, input.offset + input.limit);
+			}
 			const sort = createMongoSort(input);
 			return sort === void 0 ? cursor.toArray() : cursor.sort(sort).toArray();
 		}
@@ -108,6 +153,18 @@ const createMongoReads = (collections, session) => ({
 			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));
+			case "bundle_installations": return collections.bundleInstallations.countDocuments(createMongoInstallationWhere(input.where), {
+				...mongoSessionOptions(session),
+				collation: { locale: "simple" },
+				readPreference: "primary",
+				...session === void 0 ? { readConcern: { level: "snapshot" } } : {}
+			});
+			case "bundle_events": return collections.bundleEvents.countDocuments(createMongoEventWhere(input.where), {
+				...mongoSessionOptions(session),
+				collation: { locale: "simple" },
+				readPreference: "primary",
+				...session === void 0 ? { readConcern: { level: "snapshot" } } : {}
+			});
 		}
 	},
 	findOne: async (input) => {
@@ -136,6 +193,12 @@ const createMongoReads = (collections, session) => ({
 				projection: WITHOUT_MONGO_ID,
 				...mongoSessionOptions(session)
 			});
+			case "bundle_installations": return collections.bundleInstallations.findOne(createMongoInstallationWhere(input.where), {
+				projection: WITHOUT_MONGO_ID,
+				...mongoSessionOptions(session),
+				collation: { locale: "simple" },
+				readPreference: "primary"
+			});
 		}
 	},
 	findMany: (input) => {

package/dist/adapters/mongodbWrites.cjs

@@ -1,10 +1,9 @@
-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]));
+	const ids = Array.from(/* @__PURE__ */ 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) => ({
@@ -51,6 +50,16 @@ const createMongoWrites = (collections, session) => ({
 			case "bundle_events":
 				await collections.bundleEvents.insertOne(input.data, require_mongodbCollections.mongoSessionOptions(session));
 				return input.data;
+			case "bundle_installations":
+				if (input.onConflict === "ignore") {
+					await collections.bundleInstallations.updateOne({ install_id: input.data.install_id }, { $setOnInsert: input.data }, {
+						upsert: true,
+						...require_mongodbCollections.mongoSessionOptions(session)
+					});
+					return input.data;
+				}
+				await collections.bundleInstallations.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;
@@ -80,6 +89,11 @@ const createMongoWrites = (collections, session) => ({
 		}
 	},
 	update: async (input) => {
+		if (input.model === "bundle_installations") return collections.bundleInstallations.findOneAndUpdate(require_mongodbQuery.createMongoInstallationWhere(input.where), { $set: input.update }, {
+			projection: require_mongodbCollections.WITHOUT_MONGO_ID,
+			returnDocument: "after",
+			...require_mongodbCollections.mongoSessionOptions(session)
+		});
 		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",

package/dist/adapters/mongodbWrites.mjs

@@ -1,9 +1,9 @@
-import { DELETION_TOKEN_FIELD, MongoAdapterConstraintError, WITHOUT_INTERNAL_FIELDS, activeBundleFilter, mongoSessionOptions } from "./mongodbCollections.mjs";
-import { createMongoApiKeyWhere, createMongoBundleWhere, createMongoChannelWhere, createMongoPatchWhere, createMongoReleaseCatalogWhere, createMongoReleaseWhere } from "./mongodbQuery.mjs";
+import { DELETION_TOKEN_FIELD, MongoAdapterConstraintError, WITHOUT_INTERNAL_FIELDS, WITHOUT_MONGO_ID, activeBundleFilter, mongoSessionOptions } from "./mongodbCollections.mjs";
+import { createMongoApiKeyWhere, createMongoBundleWhere, createMongoChannelWhere, createMongoInstallationWhere, 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]));
+	const ids = Array.from(/* @__PURE__ */ 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) => ({
@@ -50,6 +50,16 @@ const createMongoWrites = (collections, session) => ({
 			case "bundle_events":
 				await collections.bundleEvents.insertOne(input.data, mongoSessionOptions(session));
 				return input.data;
+			case "bundle_installations":
+				if (input.onConflict === "ignore") {
+					await collections.bundleInstallations.updateOne({ install_id: input.data.install_id }, { $setOnInsert: input.data }, {
+						upsert: true,
+						...mongoSessionOptions(session)
+					});
+					return input.data;
+				}
+				await collections.bundleInstallations.insertOne(input.data, mongoSessionOptions(session));
+				return input.data;
 			case "releases":
 				await collections.releases.insertOne(input.data, mongoSessionOptions(session));
 				return input.data;
@@ -79,6 +89,11 @@ const createMongoWrites = (collections, session) => ({
 		}
 	},
 	update: async (input) => {
+		if (input.model === "bundle_installations") return collections.bundleInstallations.findOneAndUpdate(createMongoInstallationWhere(input.where), { $set: input.update }, {
+			projection: WITHOUT_MONGO_ID,
+			returnDocument: "after",
+			...mongoSessionOptions(session)
+		});
 		if (input.model === "api_keys") return collections.apiKeys.findOneAndUpdate(createMongoApiKeyWhere(input.where), { $set: input.update }, {
 			projection: WITHOUT_INTERNAL_FIELDS,
 			returnDocument: "after",

package/dist/adapters/prisma.cjs

@@ -1,5 +1,4 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-require("../_virtual/_rolldown/runtime.cjs");
 const require_registry = require("../db/schema/registry.cjs");
 const require_schemaGenerators = require("../db/schemaGenerators.cjs");
 const require_databaseConstraintErrors = require("./databaseConstraintErrors.cjs");
@@ -10,14 +9,14 @@ let _hot_updater_plugin_core = require("@hot-updater/plugin-core");
 let _hot_updater_plugin_core_internal = require("@hot-updater/plugin-core/internal");
 //#region src/adapters/prisma.ts
 const hasCallbackTransaction = (client) => "$transaction" in client && typeof client.$transaction === "function";
-const runPrismaTransaction = (client, isolationLevel, callback) => {
+const runPrismaTransaction = (client, isolationLevel, callback, retryUniqueConflict = false) => {
 	const execute = () => isolationLevel === "serializable" ? client.$transaction(callback, { isolationLevel: "Serializable" }) : client.$transaction(callback);
 	if (isolationLevel === "default") return execute();
 	return (async () => {
 		for (let attempt = 0;; attempt += 1) try {
 			return await execute();
 		} catch (error) {
-			if (attempt >= 2 || typeof error !== "object" || error === null || !("code" in error) || error.code !== "P2034") throw error;
+			if (attempt >= 2 || typeof error !== "object" || error === null || !("code" in error) || error.code !== "P2034" && !(retryUniqueConflict && error.code === "P2002")) throw error;
 		}
 	})();
 };
@@ -38,6 +37,7 @@ const findMany = async (client, input, provider) => {
 		case "bundles": return require_prismaRows.parsePrismaRows(rows, require_prismaRows.parsePrismaBundleRow);
 		case "bundle_patches": return require_prismaRows.parsePrismaRows(rows, require_prismaRows.parsePrismaPatchRow);
 		case "bundle_events": return require_prismaRows.parsePrismaRows(rows, require_prismaRows.parsePrismaBundleEventRow);
+		case "bundle_installations": return require_prismaRows.parsePrismaRows(rows, require_prismaRows.parsePrismaInsightsInstallationRow);
 		case "channels": return require_prismaRows.parsePrismaRows(rows, require_prismaRows.parsePrismaChannelRow);
 		case "api_keys": return require_prismaRows.parsePrismaRows(rows, require_prismaRows.parsePrismaApiKeyRow);
 		case "releases": return require_prismaRows.parsePrismaRows(rows, require_prismaRows.parsePrismaReleaseRow);
@@ -45,7 +45,7 @@ const findMany = async (client, input, provider) => {
 	}
 };
 const assertPatchReferences = async (client, bundleId, baseBundleId) => {
-	const ids = Array.from(new Set([bundleId, baseBundleId]));
+	const ids = Array.from(/* @__PURE__ */ new Set([bundleId, baseBundleId]));
 	if (await require_prismaRows.getPrismaDelegate(client, "bundles").count({ where: { id: { in: ids } } }) !== ids.length) throw new require_prismaRows.PrismaAdapterError("patch references a missing bundle");
 };
 const createCrudImplementation = (client, provider, relationMode) => ({
@@ -92,7 +92,7 @@ const createCrudImplementation = (client, provider, relationMode) => ({
 		const delegate = require_prismaRows.getPrismaDelegate(client, input.model);
 		let row;
 		if (input.onConflict === "ignore") {
-			const where = input.model === "channels" ? { name: input.data.name } : { hash: input.data.hash };
+			const where = input.model === "channels" ? { name: input.data.name } : input.model === "api_keys" ? { hash: input.data.hash } : { install_id: input.data.install_id };
 			row = await delegate.upsert({
 				where,
 				create: input.data,
@@ -103,6 +103,7 @@ const createCrudImplementation = (client, provider, relationMode) => ({
 			case "bundles": return require_prismaRows.parsePrismaBundleRow(row);
 			case "bundle_patches": return require_prismaRows.parsePrismaPatchRow(row);
 			case "bundle_events": return require_prismaRows.parsePrismaBundleEventRow(row);
+			case "bundle_installations": return require_prismaRows.parsePrismaInsightsInstallationRow(row);
 			case "channels": return require_prismaRows.parsePrismaChannelRow(row);
 			case "api_keys": return require_prismaRows.parsePrismaApiKeyRow(row);
 			case "releases": return require_prismaRows.parsePrismaReleaseRow(row);
@@ -110,6 +111,18 @@ const createCrudImplementation = (client, provider, relationMode) => ({
 		}
 	},
 	update: async (input) => {
+		if (input.model === "bundle_installations") {
+			const installId = input.where.find((item) => item.field === "install_id" && (item.operator === void 0 || item.operator === "eq") && typeof item.value === "string")?.value;
+			if (typeof installId !== "string") throw new require_prismaRows.PrismaAdapterError("bundle_installations update requires install_id");
+			const delegate = require_prismaRows.getPrismaDelegate(client, "bundle_installations");
+			if (delegate.updateMany === void 0) throw new require_prismaRows.PrismaAdapterError("model delegate \"bundle_installations\" requires updateMany");
+			if ((await delegate.updateMany({
+				where: require_prismaQuery.createPrismaWhere(input.where, provider),
+				data: input.update
+			})).count === 0) return null;
+			const stored = await delegate.findFirst({ where: { install_id: installId } });
+			return stored === null ? null : require_prismaRows.parsePrismaInsightsInstallationRow(stored);
+		}
 		const id = input.where[0]?.value;
 		if (typeof id !== "string") throw new require_prismaRows.PrismaAdapterError(`${input.model} update requires a string id`);
 		if (input.model === "api_keys") {
@@ -155,7 +168,8 @@ const createCrudImplementation = (client, provider, relationMode) => ({
 	},
 	delete: async (input) => {
 		if (input.model === "bundles" && relationMode === "prisma") {
-			const ids = require_prismaRows.parsePrismaRows(await require_prismaRows.getPrismaDelegate(client, "bundles").findMany({ where: require_prismaQuery.createPrismaWhere(input.where, provider) }), require_prismaRows.parsePrismaBundleRow).map(({ id }) => id);
+			const rows = await require_prismaRows.getPrismaDelegate(client, "bundles").findMany({ where: require_prismaQuery.createPrismaWhere(input.where, provider) });
+			const ids = require_prismaRows.parsePrismaRows(rows, require_prismaRows.parsePrismaBundleRow).map(({ id }) => id);
 			if (ids.length === 0) return;
 			await require_prismaRows.getPrismaDelegate(client, "bundle_patches").deleteMany({ where: { OR: [{ bundle_id: { in: ids } }, { base_bundle_id: { in: ids } }] } });
 		}
@@ -180,6 +194,7 @@ const createCrudImplementation = (client, provider, relationMode) => ({
 			case "api_keys": return require_prismaRows.parsePrismaApiKeyRow(row);
 			case "releases": return require_prismaRows.parsePrismaReleaseRow(row);
 			case "release_catalogs": return require_prismaRows.parsePrismaReleaseCatalogRow(row);
+			case "bundle_installations": return require_prismaRows.parsePrismaInsightsInstallationRow(row);
 		}
 	},
 	findMany: (input) => findMany(client, input, provider)
@@ -188,6 +203,26 @@ const createPrismaImplementation = (client, relationMode, provider) => {
 	const crud = createCrudImplementation(client, provider, relationMode);
 	const implementation = {
 		...crud,
+		recordInsights: (input) => {
+			if (!hasCallbackTransaction(client)) throw new require_prismaRows.PrismaAdapterError("Insights recording requires callback transactions");
+			return runPrismaTransaction(client, "serializable", async (transactionClient) => {
+				const events = require_prismaRows.getPrismaDelegate(transactionClient, "bundle_events");
+				if (await events.findFirst({ where: { id: input.event.id } }) !== null) return;
+				await events.create({ data: input.event });
+				const installations = require_prismaRows.getPrismaDelegate(transactionClient, "bundle_installations");
+				const existing = await installations.findFirst({ where: { install_id: input.installation.install_id } });
+				if (existing === null) {
+					await installations.create({ data: input.installation });
+					return;
+				}
+				const current = require_prismaRows.parsePrismaInsightsInstallationRow(existing);
+				if (current.received_at_ms > input.installation.received_at_ms || current.received_at_ms === input.installation.received_at_ms && current.id >= input.installation.id) return;
+				await installations.update({
+					where: { install_id: input.installation.install_id },
+					data: input.installation
+				});
+			}, true);
+		},
 		deleteChannel: (input) => {
 			if (!hasCallbackTransaction(client)) throw new require_prismaRows.PrismaAdapterError("channel deletion requires callback transactions");
 			return runPrismaTransaction(client, "serializable", (transactionClient) => createCrudImplementation(transactionClient, provider, relationMode).deleteChannel(input));
@@ -212,9 +247,22 @@ const createPrismaImplementation = (client, relationMode, provider) => {
 const prismaAdapter = (config) => {
 	assertPrismaProvider(config.provider);
 	const adapter = (0, _hot_updater_plugin_core_internal.createDatabasePluginAdapter)("prisma", createPrismaImplementation(config.prisma, config.relationMode ?? "foreign-keys", config.provider));
+	const unsupportedMssqlInsights = async () => {
+		throw new require_prismaRows.PrismaAdapterError("SQL Server Insights is unsupported: string keys pad trailing spaces and do not provide the required exact UTF-8 identity ordering");
+	};
+	const insights = config.provider === "mssql" ? {
+		record: unsupportedMssqlInsights,
+		listEvents: unsupportedMssqlInsights,
+		findInstallations: unsupportedMssqlInsights,
+		countInstallations: unsupportedMssqlInsights,
+		countEvents: unsupportedMssqlInsights
+	} : adapter.models.insights;
 	return Object.assign((0, _hot_updater_plugin_core.createDatabasePlugin)({
 		name: "prisma",
-		models: adapter.models,
+		models: {
+			...adapter.models,
+			insights
+		},
 		commit: adapter.commit
 	}), {
 		adapterName: "prisma",

package/dist/adapters/prisma.d.cts

@@ -1,5 +1,4 @@
 import { DatabaseAdapterWithCapabilities, ORMSQLProvider } from "../db/types.cjs";
-
 //#region src/adapters/prisma.d.ts
 type PrismaRelationMode = "prisma" | "foreign-keys";
 interface PrismaConfig {

package/dist/adapters/prisma.d.mts

@@ -1,5 +1,4 @@
 import { DatabaseAdapterWithCapabilities, ORMSQLProvider } from "../db/types.mjs";
-
 //#region src/adapters/prisma.d.ts
 type PrismaRelationMode = "prisma" | "foreign-keys";
 interface PrismaConfig {