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

package/dist/adapters/prisma.cjs

@@ -2,202 +2,227 @@ 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_bundleRows = require("../db/bundleRows.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");
 let _hot_updater_plugin_core = require("@hot-updater/plugin-core");
-let _hot_updater_core = require("@hot-updater/core");
+let _hot_updater_plugin_core_internal = require("@hot-updater/plugin-core/internal");
 //#region src/adapters/prisma.ts
-const assertSupportedRelationMode = (relationMode) => {
-	if (relationMode && relationMode !== "prisma" && relationMode !== "foreign-keys") throw new Error(`Unsupported Prisma relation mode: ${relationMode}`);
+const hasCallbackTransaction = (client) => "$transaction" in client && typeof client.$transaction === "function";
+const runPrismaTransaction = (client, isolationLevel, callback) => {
+	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;
+		}
+	})();
 };
-const getDelegate = (prisma, model) => {
-	const delegate = prisma[model];
-	if (!delegate || typeof delegate !== "object") throw new Error(`Prisma client is missing model delegate "${model}".`);
-	return delegate;
+const assertPrismaProvider = (provider) => {
+	if (provider === "mongodb") throw new require_prismaRows.PrismaAdapterError("Prisma adapter does not support MongoDB; use mongodbAdapter instead");
 };
-const prismaWhere = (where) => {
-	const targetAppVersionFilters = [];
-	if (where?.targetAppVersion !== void 0) targetAppVersionFilters.push({ target_app_version: where.targetAppVersion });
-	if (where?.targetAppVersionIn) targetAppVersionFilters.push({ target_app_version: { in: where.targetAppVersionIn } });
-	if (where?.targetAppVersionNotNull) targetAppVersionFilters.push({ target_app_version: { not: null } });
-	return {
-		...where?.channel !== void 0 ? { channel: where.channel } : {},
-		...where?.platform !== void 0 ? { platform: where.platform } : {},
-		...where?.enabled !== void 0 ? { enabled: where.enabled } : {},
-		...where?.fingerprintHash !== void 0 ? { fingerprint_hash: where.fingerprintHash } : {},
-		...where?.id ? { id: {
-			...where.id.eq !== void 0 ? { equals: where.id.eq } : {},
-			...where.id.gt !== void 0 ? { gt: where.id.gt } : {},
-			...where.id.gte !== void 0 ? { gte: where.id.gte } : {},
-			...where.id.lt !== void 0 ? { lt: where.id.lt } : {},
-			...where.id.lte !== void 0 ? { lte: where.id.lte } : {},
-			...where.id.in !== void 0 ? { in: where.id.in } : {}
-		} } : {},
-		...targetAppVersionFilters.length > 0 ? { AND: targetAppVersionFilters } : {}
-	};
+const findMany = async (client, input, provider) => {
+	if (input.distinctOn !== void 0) throw new _hot_updater_plugin_core.DatabasePluginInputError("invalid-operation");
+	const rawOrderBy = input.orderBy;
+	const orderBy = require_prismaQuery.createPrismaOrderBy(rawOrderBy);
+	const rows = rawOrderBy !== void 0 && require_databasePluginUtils.hasNullOrderOverrides(rawOrderBy) ? require_databasePluginUtils.sortRowsByOrder(await require_prismaRows.getPrismaDelegate(client, input.model).findMany({ where: require_prismaQuery.createPrismaWhere(input.where, provider) }), rawOrderBy).slice(input.offset, input.offset + input.limit) : await require_prismaRows.getPrismaDelegate(client, input.model).findMany({
+		where: require_prismaQuery.createPrismaWhere(input.where, provider),
+		...orderBy ? { orderBy } : {},
+		skip: input.offset,
+		take: input.limit
+	});
+	switch (input.model) {
+		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 "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);
+		case "release_catalogs": return require_prismaRows.parsePrismaRows(rows, require_prismaRows.parsePrismaReleaseCatalogRow);
+	}
 };
-const createPrismaPlugin = (0, _hot_updater_plugin_core.createDatabasePlugin)({
-	name: "prisma",
-	factory: (config) => {
-		const prisma = config.prisma;
-		const runInTransaction = async (operation) => {
-			if (typeof prisma.$transaction !== "function") return operation(prisma);
-			return prisma.$transaction(operation);
-		};
-		const fetchPatchMap = async (bundleIds) => {
-			const patches = getDelegate(prisma, "bundle_patches");
-			const patchMap = /* @__PURE__ */ new Map();
-			if (bundleIds.length === 0) return patchMap;
-			const rows = await patches.findMany({
-				where: { bundle_id: { in: [...bundleIds] } },
-				orderBy: { order_index: "asc" }
-			});
-			for (const row of rows) {
-				const patch = row;
-				const current = patchMap.get(patch.bundle_id) ?? [];
-				current.push(patch);
-				patchMap.set(patch.bundle_id, current);
-			}
-			return patchMap;
+const assertPatchReferences = async (client, bundleId, baseBundleId) => {
+	const ids = Array.from(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) => ({
+	deleteChannel: async ({ id }) => {
+		const channels = require_prismaRows.getPrismaDelegate(client, "channels");
+		if (await channels.findFirst({ where: { id } }) === null) return {
+			deleted: false,
+			reason: "not_found"
 		};
-		const mapRowsToBundles = async (rows) => {
-			const patchMap = await fetchPatchMap(rows.map((row) => String(row["id"])));
-			return rows.map((row) => require_bundleRows.rowToBundle(row, patchMap.get(String(row["id"])) ?? []));
+		if (await require_prismaRows.getPrismaDelegate(client, "releases").count({ where: { channel_id: id } }) > 0) return {
+			deleted: false,
+			reason: "not_empty"
 		};
-		const upsertBundle = async (client, bundle) => {
-			const bundles = getDelegate(client, "bundles");
-			const patches = getDelegate(client, "bundle_patches");
-			const row = require_bundleRows.bundleToRow(bundle);
-			const { id, ...update } = row;
-			await bundles.upsert({
-				where: { id },
-				create: row,
-				update
-			});
-			await patches.deleteMany({ where: { bundle_id: id } });
-			const patchRows = require_bundleRows.bundleToPatchRows(bundle);
-			if (patchRows.length > 0) await patches.createMany({ data: patchRows });
+		try {
+			await channels.deleteMany({ where: { id } });
+		} catch (error) {
+			if (require_databaseConstraintErrors.isChannelDeleteReferencedError(error)) return {
+				deleted: false,
+				reason: "not_empty"
+			};
+			throw error;
+		}
+		return { deleted: true };
+	},
+	insertChannel: async (input) => {
+		const delegate = require_prismaRows.getPrismaDelegate(client, "channels");
+		const existing = await delegate.findFirst({ where: { name: input.row.name } });
+		if (existing !== null) return {
+			row: require_prismaRows.parsePrismaChannelRow(existing),
+			inserted: false
 		};
+		const row = require_prismaRows.parsePrismaChannelRow(await delegate.upsert({
+			where: { name: input.row.name },
+			create: input.row,
+			update: {}
+		}));
 		return {
-			async getBundleById(bundleId) {
-				const row = await getDelegate(prisma, "bundles").findFirst({ where: { id: bundleId } });
-				if (!row) return null;
-				return require_bundleRows.rowToBundle(row, (await fetchPatchMap([bundleId])).get(bundleId) ?? []);
-			},
-			async getBundles(options) {
-				const bundles = getDelegate(prisma, "bundles");
-				const offset = options.offset ?? 0;
-				const orderBy = options.orderBy ?? {
-					field: "id",
-					direction: "desc"
-				};
-				const where = prismaWhere(options.where);
-				const [total, rows] = await Promise.all([bundles.count({ where }), bundles.findMany({
-					where,
-					orderBy: { id: orderBy.direction },
-					skip: offset,
-					take: options.limit
-				})]);
-				const patchMap = await fetchPatchMap(rows.map((row) => String(row["id"])));
-				return {
-					data: rows.map((row) => require_bundleRows.rowToBundle(row, patchMap.get(String(row["id"])) ?? [])),
-					pagination: (0, _hot_updater_plugin_core.calculatePagination)(total, {
-						limit: options.limit,
-						offset
-					})
-				};
-			},
-			async getUpdateInfo(args, context) {
-				const bundles = getDelegate(prisma, "bundles");
-				if (args._updateStrategy === "appVersion") {
-					const channel = args.channel ?? "production";
-					const minBundleId = args.minBundleId ?? _hot_updater_core.NIL_UUID;
-					const rows = await bundles.findMany({
-						select: { target_app_version: true },
-						where: {
-							enabled: true,
-							platform: args.platform,
-							channel,
-							id: { gte: minBundleId },
-							target_app_version: { not: null }
-						}
-					});
-					const compatibleAppVersions = (0, _hot_updater_plugin_core.filterCompatibleAppVersions)(Array.from(new Set(rows.map((row) => row["target_app_version"]).filter((value) => typeof value === "string" && value.length > 0))), args.appVersion);
-					const updateBundles = compatibleAppVersions.length > 0 ? await bundles.findMany({
-						where: {
-							enabled: true,
-							platform: args.platform,
-							channel,
-							id: { gte: minBundleId },
-							target_app_version: { in: compatibleAppVersions }
-						},
-						orderBy: { id: "desc" }
-					}).then(mapRowsToBundles) : [];
-					return (0, _hot_updater_plugin_core.resolveUpdateInfoFromBundles)({
-						args: {
-							...args,
-							channel,
-							minBundleId
-						},
-						bundles: updateBundles,
-						context
-					});
-				}
-				const channel = args.channel ?? "production";
-				const minBundleId = args.minBundleId ?? _hot_updater_core.NIL_UUID;
-				const rows = await bundles.findMany({
-					where: {
-						enabled: true,
-						platform: args.platform,
-						channel,
-						id: { gte: minBundleId },
-						fingerprint_hash: args.fingerprintHash
-					},
-					orderBy: { id: "desc" }
-				});
-				return (0, _hot_updater_plugin_core.resolveUpdateInfoFromBundles)({
-					args: {
-						...args,
-						channel,
-						minBundleId
-					},
-					bundles: await mapRowsToBundles(rows),
-					context
-				});
-			},
-			async getChannels() {
-				const rows = await getDelegate(prisma, "bundles").findMany({
-					select: { channel: true },
-					orderBy: { channel: "asc" }
-				});
-				return Array.from(new Set(rows.map((row) => String(row["channel"]))));
-			},
-			async commitBundle({ changedSets }) {
-				await runInTransaction(async (client) => {
-					const bundles = getDelegate(client, "bundles");
-					const patches = getDelegate(client, "bundle_patches");
-					for (const change of changedSets) {
-						if (change.operation === "delete") {
-							await patches.deleteMany({ where: { bundle_id: change.data.id } });
-							await patches.deleteMany({ where: { base_bundle_id: change.data.id } });
-							await bundles.deleteMany({ where: { id: change.data.id } });
-							continue;
-						}
-						await upsertBundle(client, change.data);
-					}
-				});
-			}
+			row,
+			inserted: row.id === input.row.id
 		};
-	}
+	},
+	create: async (input) => {
+		if (input.model === "bundle_patches") await assertPatchReferences(client, input.data.bundle_id, input.data.base_bundle_id);
+		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 };
+			row = await delegate.upsert({
+				where,
+				create: input.data,
+				update: {}
+			});
+		} else row = await delegate.create({ data: input.data });
+		switch (input.model) {
+			case "bundles": return require_prismaRows.parsePrismaBundleRow(row);
+			case "bundle_patches": return require_prismaRows.parsePrismaPatchRow(row);
+			case "bundle_events": return require_prismaRows.parsePrismaBundleEventRow(row);
+			case "channels": return require_prismaRows.parsePrismaChannelRow(row);
+			case "api_keys": return require_prismaRows.parsePrismaApiKeyRow(row);
+			case "releases": return require_prismaRows.parsePrismaReleaseRow(row);
+			case "release_catalogs": return require_prismaRows.parsePrismaReleaseCatalogRow(row);
+		}
+	},
+	update: async (input) => {
+		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") {
+			const delegate = require_prismaRows.getPrismaDelegate(client, "api_keys");
+			if (await delegate.findFirst({ where: { id } }) === null) return null;
+			await delegate.update({
+				where: { id },
+				data: input.update
+			});
+			const stored = await delegate.findFirst({ where: { id } });
+			return stored === null ? null : require_prismaRows.parsePrismaApiKeyRow(stored);
+		}
+		if (input.model === "releases") {
+			const delegate = require_prismaRows.getPrismaDelegate(client, "releases");
+			if (await delegate.findFirst({ where: { id } }) === null) return null;
+			await delegate.update({
+				where: { id },
+				data: input.update
+			});
+			const stored = await delegate.findFirst({ where: { id } });
+			return stored === null ? null : require_prismaRows.parsePrismaReleaseRow(stored);
+		}
+		if (input.model === "release_catalogs") {
+			const delegate = require_prismaRows.getPrismaDelegate(client, "release_catalogs");
+			if (await delegate.findFirst({ where: { scope_key: id } }) === null) return null;
+			await delegate.update({
+				where: { scope_key: id },
+				data: input.update
+			});
+			const stored = await delegate.findFirst({ where: { scope_key: id } });
+			return stored === null ? null : require_prismaRows.parsePrismaReleaseCatalogRow(stored);
+		}
+		const delegate = require_prismaRows.getPrismaDelegate(client, "bundles");
+		if (delegate.updateMany === void 0) throw new require_prismaRows.PrismaAdapterError("model delegate \"bundles\" requires updateMany");
+		if (await delegate.findFirst({ where: { id } }) === null) return null;
+		await delegate.updateMany({
+			where: { id },
+			data: input.update
+		});
+		const stored = await delegate.findFirst({ where: { id } });
+		if (stored === null) return null;
+		return require_prismaRows.parsePrismaBundleRow(stored);
+	},
+	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);
+			if (ids.length === 0) return;
+			await require_prismaRows.getPrismaDelegate(client, "bundle_patches").deleteMany({ where: { OR: [{ bundle_id: { in: ids } }, { base_bundle_id: { in: ids } }] } });
+		}
+		try {
+			await require_prismaRows.getPrismaDelegate(client, input.model).deleteMany({ where: require_prismaQuery.createPrismaWhere(input.where, provider) });
+		} catch (error) {
+			if (input.model === "channels") require_databaseConstraintErrors.translateChannelDeleteError(error);
+			throw error;
+		}
+	},
+	count: async (input) => {
+		if (input.distinct !== void 0) throw new _hot_updater_plugin_core.DatabasePluginInputError("invalid-operation");
+		return require_prismaRows.getPrismaDelegate(client, input.model).count({ where: require_prismaQuery.createPrismaWhere(input.where, provider) });
+	},
+	findOne: async (input) => {
+		const row = await require_prismaRows.getPrismaDelegate(client, input.model).findFirst({ where: require_prismaQuery.createPrismaWhere(input.where, provider) });
+		if (row === null) return null;
+		switch (input.model) {
+			case "bundles": return require_prismaRows.parsePrismaBundleRow(row);
+			case "bundle_patches": return require_prismaRows.parsePrismaPatchRow(row);
+			case "channels": return require_prismaRows.parsePrismaChannelRow(row);
+			case "api_keys": return require_prismaRows.parsePrismaApiKeyRow(row);
+			case "releases": return require_prismaRows.parsePrismaReleaseRow(row);
+			case "release_catalogs": return require_prismaRows.parsePrismaReleaseCatalogRow(row);
+		}
+	},
+	findMany: (input) => findMany(client, input, provider)
 });
+const createPrismaImplementation = (client, relationMode, provider) => {
+	const crud = createCrudImplementation(client, provider, relationMode);
+	const implementation = {
+		...crud,
+		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));
+		},
+		delete: (input) => {
+			if (input.model !== "bundles" || relationMode === "foreign-keys") return crud.delete(input);
+			if (!hasCallbackTransaction(client)) throw new require_prismaRows.PrismaAdapterError("relation mode \"prisma\" requires callback transactions");
+			return runPrismaTransaction(client, "serializable", (transactionClient) => createCrudImplementation(transactionClient, provider, relationMode).delete(input));
+		}
+	};
+	if (relationMode === "prisma" && !hasCallbackTransaction(client)) throw new require_prismaRows.PrismaAdapterError("relation mode \"prisma\" requires callback transactions");
+	if (!hasCallbackTransaction(client)) return implementation;
+	if (relationMode === "prisma") implementation.create = (input) => runPrismaTransaction(client, "serializable", (transactionClient) => createCrudImplementation(transactionClient, provider, relationMode).create(input));
+	implementation.update = (input) => runPrismaTransaction(client, relationMode === "prisma" ? "serializable" : "default", (transactionClient) => createCrudImplementation(transactionClient, provider, relationMode).update(input));
+	return {
+		...implementation,
+		transaction: (callback) => runPrismaTransaction(client, "serializable", async (transactionClient) => {
+			return callback(createCrudImplementation(transactionClient, provider, relationMode));
+		})
+	};
+};
 const prismaAdapter = (config) => {
-	assertSupportedRelationMode(config.relationMode);
-	return Object.assign(createPrismaPlugin(config), {
+	assertPrismaProvider(config.provider);
+	const adapter = (0, _hot_updater_plugin_core_internal.createDatabasePluginAdapter)("prisma", createPrismaImplementation(config.prisma, config.relationMode ?? "foreign-keys", config.provider));
+	return Object.assign((0, _hot_updater_plugin_core.createDatabasePlugin)({
+		name: "prisma",
+		models: adapter.models,
+		commit: adapter.commit
+	}), {
 		adapterName: "prisma",
 		provider: config.provider,
-		generateSchema: (version) => ({
+		generateSchema: ((version) => ({
 			code: require_schemaGenerators.generatePrismaSchema(config.provider, version === "latest" ? require_registry.hotUpdaterSchema : require_registry.getHotUpdaterSchemaVersion(version)),
 			path: "./prisma/schema/hot_updater.prisma"
-		})
+		}))
 	});
 };
 //#endregion

package/dist/adapters/prisma.d.cts

@@ -1,13 +1,13 @@
-import { DatabasePluginFactory, ORMProvider } from "../db/types.cjs";
+import { DatabaseAdapterWithCapabilities, ORMSQLProvider } from "../db/types.cjs";
 
 //#region src/adapters/prisma.d.ts
 type PrismaRelationMode = "prisma" | "foreign-keys";
 interface PrismaConfig {
   readonly prisma: object;
-  readonly provider: ORMProvider;
+  readonly provider: ORMSQLProvider;
   readonly relationMode?: PrismaRelationMode;
   readonly db?: unknown;
 }
-declare const prismaAdapter: (config: PrismaConfig) => DatabasePluginFactory;
+declare const prismaAdapter: (config: PrismaConfig) => DatabaseAdapterWithCapabilities;
 //#endregion
 export { PrismaConfig, prismaAdapter };

package/dist/adapters/prisma.d.mts

@@ -1,13 +1,13 @@
-import { DatabasePluginFactory, ORMProvider } from "../db/types.mjs";
+import { DatabaseAdapterWithCapabilities, ORMSQLProvider } from "../db/types.mjs";
 
 //#region src/adapters/prisma.d.ts
 type PrismaRelationMode = "prisma" | "foreign-keys";
 interface PrismaConfig {
   readonly prisma: object;
-  readonly provider: ORMProvider;
+  readonly provider: ORMSQLProvider;
   readonly relationMode?: PrismaRelationMode;
   readonly db?: unknown;
 }
-declare const prismaAdapter: (config: PrismaConfig) => DatabasePluginFactory;
+declare const prismaAdapter: (config: PrismaConfig) => DatabaseAdapterWithCapabilities;
 //#endregion
 export { PrismaConfig, prismaAdapter };