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

package/dist/adapters/mongodbReads.cjs

@@ -1,8 +1,8 @@
-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");
+let _hot_updater_plugin_core_internal = require("@hot-updater/plugin-core/internal");
 //#region src/adapters/mongodbReads.ts
 const findMongoRows = async (collections, input, session) => {
 	if (input.limit === 0) return [];
@@ -15,10 +15,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 +31,33 @@ 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), {
-				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.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();
 		}
@@ -54,10 +67,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 +83,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 +99,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,22 +115,58 @@ 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();
 		}
 	}
 };
 const createMongoReads = (collections, session) => ({
+	async findLatestInsightsEvents(input) {
+		return collections.bundleEventHeads.aggregate([
+			{ $match: require_mongodbQuery.createMongoEventWhere((0, _hot_updater_plugin_core_internal.latestInsightsWhere)(input)) },
+			{ $sort: { install_id: 1 } },
+			{ $limit: "installId" in input ? 1 : input.limit },
+			{ $lookup: {
+				from: "bundle_events",
+				localField: "id",
+				foreignField: "id",
+				as: "event"
+			} },
+			{ $unwind: "$event" },
+			{ $replaceRoot: { newRoot: "$event" } },
+			{ $project: require_mongodbCollections.WITHOUT_MONGO_ID }
+		], {
+			...require_mongodbCollections.mongoSessionOptions(session),
+			collation: { locale: "simple" },
+			readPreference: "primary"
+		}).toArray();
+	},
+	async countLatestInsightsEvents(input) {
+		return (await collections.bundleEventHeads.aggregate([{ $match: { $or: (0, _hot_updater_plugin_core_internal.latestInsightsCountGroups)(input).map(require_mongodbQuery.createMongoEventWhere) } }, { $count: "count" }], {
+			...require_mongodbCollections.mongoSessionOptions(session),
+			collation: { locale: "simple" },
+			readPreference: "primary"
+		}).toArray())[0]?.count ?? 0;
+	},
 	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));
+			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) => {

package/dist/adapters/mongodbReads.mjs

@@ -2,6 +2,7 @@ import { hasNullOrderOverrides, sortRowsByOrder } from "./databasePluginUtils.mj
 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";
+import { latestInsightsCountGroups, latestInsightsWhere } from "@hot-updater/plugin-core/internal";
 //#region src/adapters/mongodbReads.ts
 const findMongoRows = async (collections, input, session) => {
 	if (input.limit === 0) return [];
@@ -14,10 +15,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 +31,33 @@ 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), {
-				projection: WITHOUT_MONGO_ID,
-				...mongoSessionOptions(session)
-			}).toArray(), rawOrderBy).slice(input.offset, input.offset + input.limit);
+			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();
 		}
@@ -53,10 +67,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 +83,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 +99,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,22 +115,58 @@ 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();
 		}
 	}
 };
 const createMongoReads = (collections, session) => ({
+	async findLatestInsightsEvents(input) {
+		return collections.bundleEventHeads.aggregate([
+			{ $match: createMongoEventWhere(latestInsightsWhere(input)) },
+			{ $sort: { install_id: 1 } },
+			{ $limit: "installId" in input ? 1 : input.limit },
+			{ $lookup: {
+				from: "bundle_events",
+				localField: "id",
+				foreignField: "id",
+				as: "event"
+			} },
+			{ $unwind: "$event" },
+			{ $replaceRoot: { newRoot: "$event" } },
+			{ $project: WITHOUT_MONGO_ID }
+		], {
+			...mongoSessionOptions(session),
+			collation: { locale: "simple" },
+			readPreference: "primary"
+		}).toArray();
+	},
+	async countLatestInsightsEvents(input) {
+		return (await collections.bundleEventHeads.aggregate([{ $match: { $or: latestInsightsCountGroups(input).map(createMongoEventWhere) } }, { $count: "count" }], {
+			...mongoSessionOptions(session),
+			collation: { locale: "simple" },
+			readPreference: "primary"
+		}).toArray())[0]?.count ?? 0;
+	},
 	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));
+			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) => {

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) => ({

package/dist/adapters/mongodbWrites.mjs

@@ -3,7 +3,7 @@ import { createMongoApiKeyWhere, createMongoBundleWhere, createMongoChannelWhere
 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) => ({

package/dist/adapters/prisma.cjs

@@ -1,23 +1,23 @@
 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");
 const require_databasePluginUtils = require("./databasePluginUtils.cjs");
-const require_prismaQuery = require("./prismaQuery.cjs");
 const require_prismaRows = require("./prismaRows.cjs");
+const require_prismaInsights = require("./prismaInsights.cjs");
+const require_prismaQuery = require("./prismaQuery.cjs");
 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" && !(error.code === "P2010" && "meta" in error && typeof error.meta === "object" && error.meta !== null && "code" in error.meta && error.meta.code === "40001") && !(retryUniqueConflict && error.code === "P2002")) throw error;
 		}
 	})();
 };
@@ -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) => ({
@@ -155,7 +155,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 } }] } });
 		}
@@ -188,6 +189,29 @@ const createPrismaImplementation = (client, relationMode, provider) => {
 	const crud = createCrudImplementation(client, provider, relationMode);
 	const implementation = {
 		...crud,
+		async recordInsights({ event }) {
+			if (!hasCallbackTransaction(client)) return require_prismaInsights.recordPrismaEventWithCte(client, provider, event);
+			const events = require_prismaRows.getPrismaDelegate(client, "bundle_events");
+			try {
+				await runPrismaTransaction(client, provider === "cockroachdb" ? "serializable" : "default", async (transaction) => {
+					await require_prismaRows.getPrismaDelegate(transaction, "bundle_events").create({ data: event });
+					await require_prismaInsights.updatePrismaEventHead(transaction, provider, event);
+				});
+			} catch (error) {
+				if (typeof error !== "object" || error === null || !("code" in error) || error.code !== "P2002") throw error;
+				if (await events.findFirst({ where: { id: event.id } }) === null) throw error;
+			}
+		},
+		async findLatestInsightsEvents(input) {
+			const rows = await require_prismaInsights.queryPrismaLatestEvents(client, provider, input);
+			if (typeof rows === "number") throw new require_prismaRows.PrismaAdapterError("invalid latest-event rows");
+			return rows;
+		},
+		async countLatestInsightsEvents(input) {
+			const count = await require_prismaInsights.queryPrismaLatestEvents(client, provider, input);
+			if (typeof count !== "number") throw new require_prismaRows.PrismaAdapterError("invalid latest-event count");
+			return count;
+		},
 		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 +236,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" ? {
+		recordEvent: unsupportedMssqlInsights,
+		listEvents: unsupportedMssqlInsights,
+		findLatestEvents: unsupportedMssqlInsights,
+		countLatestEvents: 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 {

package/dist/adapters/prisma.mjs

@@ -2,20 +2,21 @@ import { getHotUpdaterSchemaVersion, hotUpdaterSchema } from "../db/schema/regis
 import { generatePrismaSchema } from "../db/schemaGenerators.mjs";
 import { isChannelDeleteReferencedError, translateChannelDeleteError } from "./databaseConstraintErrors.mjs";
 import { hasNullOrderOverrides, sortRowsByOrder } from "./databasePluginUtils.mjs";
-import { createPrismaOrderBy, createPrismaWhere } from "./prismaQuery.mjs";
 import { PrismaAdapterError, getPrismaDelegate, parsePrismaApiKeyRow, parsePrismaBundleEventRow, parsePrismaBundleRow, parsePrismaChannelRow, parsePrismaPatchRow, parsePrismaReleaseCatalogRow, parsePrismaReleaseRow, parsePrismaRows } from "./prismaRows.mjs";
+import { queryPrismaLatestEvents, recordPrismaEventWithCte, updatePrismaEventHead } from "./prismaInsights.mjs";
+import { createPrismaOrderBy, createPrismaWhere } from "./prismaQuery.mjs";
 import { DatabasePluginInputError, createDatabasePlugin } from "@hot-updater/plugin-core";
 import { createDatabasePluginAdapter } from "@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" && !(error.code === "P2010" && "meta" in error && typeof error.meta === "object" && error.meta !== null && "code" in error.meta && error.meta.code === "40001") && !(retryUniqueConflict && error.code === "P2002")) throw error;
 		}
 	})();
 };
@@ -43,7 +44,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 getPrismaDelegate(client, "bundles").count({ where: { id: { in: ids } } }) !== ids.length) throw new PrismaAdapterError("patch references a missing bundle");
 };
 const createCrudImplementation = (client, provider, relationMode) => ({
@@ -153,7 +154,8 @@ const createCrudImplementation = (client, provider, relationMode) => ({
 	},
 	delete: async (input) => {
 		if (input.model === "bundles" && relationMode === "prisma") {
-			const ids = parsePrismaRows(await getPrismaDelegate(client, "bundles").findMany({ where: createPrismaWhere(input.where, provider) }), parsePrismaBundleRow).map(({ id }) => id);
+			const rows = await getPrismaDelegate(client, "bundles").findMany({ where: createPrismaWhere(input.where, provider) });
+			const ids = parsePrismaRows(rows, parsePrismaBundleRow).map(({ id }) => id);
 			if (ids.length === 0) return;
 			await getPrismaDelegate(client, "bundle_patches").deleteMany({ where: { OR: [{ bundle_id: { in: ids } }, { base_bundle_id: { in: ids } }] } });
 		}
@@ -186,6 +188,29 @@ const createPrismaImplementation = (client, relationMode, provider) => {
 	const crud = createCrudImplementation(client, provider, relationMode);
 	const implementation = {
 		...crud,
+		async recordInsights({ event }) {
+			if (!hasCallbackTransaction(client)) return recordPrismaEventWithCte(client, provider, event);
+			const events = getPrismaDelegate(client, "bundle_events");
+			try {
+				await runPrismaTransaction(client, provider === "cockroachdb" ? "serializable" : "default", async (transaction) => {
+					await getPrismaDelegate(transaction, "bundle_events").create({ data: event });
+					await updatePrismaEventHead(transaction, provider, event);
+				});
+			} catch (error) {
+				if (typeof error !== "object" || error === null || !("code" in error) || error.code !== "P2002") throw error;
+				if (await events.findFirst({ where: { id: event.id } }) === null) throw error;
+			}
+		},
+		async findLatestInsightsEvents(input) {
+			const rows = await queryPrismaLatestEvents(client, provider, input);
+			if (typeof rows === "number") throw new PrismaAdapterError("invalid latest-event rows");
+			return rows;
+		},
+		async countLatestInsightsEvents(input) {
+			const count = await queryPrismaLatestEvents(client, provider, input);
+			if (typeof count !== "number") throw new PrismaAdapterError("invalid latest-event count");
+			return count;
+		},
 		deleteChannel: (input) => {
 			if (!hasCallbackTransaction(client)) throw new PrismaAdapterError("channel deletion requires callback transactions");
 			return runPrismaTransaction(client, "serializable", (transactionClient) => createCrudImplementation(transactionClient, provider, relationMode).deleteChannel(input));
@@ -210,9 +235,22 @@ const createPrismaImplementation = (client, relationMode, provider) => {
 const prismaAdapter = (config) => {
 	assertPrismaProvider(config.provider);
 	const adapter = createDatabasePluginAdapter("prisma", createPrismaImplementation(config.prisma, config.relationMode ?? "foreign-keys", config.provider));
+	const unsupportedMssqlInsights = async () => {
+		throw new 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" ? {
+		recordEvent: unsupportedMssqlInsights,
+		listEvents: unsupportedMssqlInsights,
+		findLatestEvents: unsupportedMssqlInsights,
+		countLatestEvents: unsupportedMssqlInsights,
+		countEvents: unsupportedMssqlInsights
+	} : adapter.models.insights;
 	return Object.assign(createDatabasePlugin({
 		name: "prisma",
-		models: adapter.models,
+		models: {
+			...adapter.models,
+			insights
+		},
 		commit: adapter.commit
 	}), {
 		adapterName: "prisma",