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

package/dist/adapters/drizzleCrud.mjs

@@ -0,0 +1,249 @@
+import { isChannelDeleteReferencedError, translateChannelDeleteError } from "./databaseConstraintErrors.mjs";
+import { fromStoredBundleRow, fromStoredReleaseCatalogRow, fromStoredReleaseRow, toStoredBundleRow, toStoredBundleUpdate, toStoredReleaseRow, toStoredReleaseUpdate } from "./databasePluginUtils.mjs";
+import { buildDrizzleWhere } from "./drizzleQuery.mjs";
+import { DatabasePluginInputError } from "@hot-updater/plugin-core";
+import { asc, desc, eq, sql } from "drizzle-orm";
+//#region src/adapters/drizzleCrud.ts
+var MissingDrizzleTableError = class extends Error {
+	name = "MissingDrizzleTableError";
+	constructor(table) {
+		super(`Drizzle schema is missing table "${table}".`);
+		this.table = table;
+	}
+};
+var DrizzleAdapterInvariantError = class extends Error {
+	name = "DrizzleAdapterInvariantError";
+};
+const getDrizzleTable = (db, name) => {
+	const table = db._.fullSchema[name];
+	if (table === void 0) throw new MissingDrizzleTableError(name);
+	return table;
+};
+const isSQLWrapper = (value) => typeof value === "object" && value !== null && "getSQL" in value && typeof value.getSQL === "function";
+const getDrizzleColumn = (table, name) => {
+	const value = table[name];
+	if (!isSQLWrapper(value)) throw new MissingDrizzleTableError(`${name} column`);
+	return value;
+};
+const executeInsert = async (db, provider, table, data, onConflict) => {
+	const builder = db.insert(table);
+	const insert = builder.values(data);
+	if (onConflict === void 0) {
+		await insert.execute();
+		return;
+	}
+	const ignored = provider === "mysql" ? builder.ignore?.().values(data) : insert.onConflictDoNothing?.();
+	if (ignored === void 0) throw new DrizzleAdapterInvariantError();
+	await ignored.execute();
+};
+const toOrderBy = (table, input) => {
+	return input.orderBy?.flatMap((clause) => {
+		const column = getDrizzleColumn(table, clause.field);
+		return [(clause.nulls ?? (clause.direction === "asc" ? "last" : "first")) === "first" ? sql`${column} is null desc` : sql`${column} is null asc`, clause.direction === "asc" ? asc(column) : desc(column)];
+	});
+};
+const createDrizzleCrud = (db, provider) => {
+	const bundles = getDrizzleTable(db, "bundles");
+	const patches = getDrizzleTable(db, "bundle_patches");
+	const events = getDrizzleTable(db, "bundle_events");
+	const releases = getDrizzleTable(db, "releases");
+	const releaseCatalogs = getDrizzleTable(db, "release_catalogs");
+	const channels = getDrizzleTable(db, "channels");
+	const apiKeys = getDrizzleTable(db, "api_keys");
+	return {
+		async deleteChannel({ id }) {
+			const idPredicate = eq(getDrizzleColumn(channels, "id"), id);
+			if (await db.query.channels.findFirst({ where: idPredicate }) === void 0) return {
+				deleted: false,
+				reason: "not_found"
+			};
+			if (await db.$count(releases, eq(getDrizzleColumn(releases, "channel_id"), id)) > 0) return {
+				deleted: false,
+				reason: "not_empty"
+			};
+			try {
+				await db.delete(channels).where(idPredicate).execute();
+			} catch (error) {
+				if (isChannelDeleteReferencedError(error)) return {
+					deleted: false,
+					reason: "not_empty"
+				};
+				throw error;
+			}
+			return { deleted: true };
+		},
+		async insertChannel(input) {
+			const before = await db.query.channels.findFirst({ where: eq(getDrizzleColumn(channels, "name"), input.row.name) });
+			if (before !== void 0) return {
+				row: before,
+				inserted: false
+			};
+			await executeInsert(db, provider, channels, input.row, "ignore");
+			const row = await db.query.channels.findFirst({ where: eq(getDrizzleColumn(channels, "name"), input.row.name) });
+			if (row === void 0) throw new DrizzleAdapterInvariantError();
+			return {
+				row,
+				inserted: row.id === input.row.id
+			};
+		},
+		async create(input) {
+			switch (input.model) {
+				case "bundles":
+					await executeInsert(db, provider, bundles, toStoredBundleRow(input.data, provider), void 0);
+					return input.data;
+				case "bundle_patches":
+					await executeInsert(db, provider, patches, input.data, void 0);
+					return input.data;
+				case "bundle_events":
+					await executeInsert(db, provider, events, input.data, void 0);
+					return input.data;
+				case "releases":
+					await executeInsert(db, provider, releases, toStoredReleaseRow(input.data, provider), void 0);
+					return input.data;
+				case "release_catalogs":
+					await executeInsert(db, provider, releaseCatalogs, input.data, void 0);
+					return input.data;
+				case "api_keys":
+					await executeInsert(db, provider, apiKeys, input.data, input.onConflict);
+					return input.data;
+				case "channels":
+					await executeInsert(db, provider, channels, input.data, input.onConflict);
+					return input.data;
+			}
+		},
+		async update(input) {
+			const selector = input.where[0];
+			if (selector === void 0 || typeof selector.value !== "string") throw new DrizzleAdapterInvariantError();
+			if (input.model === "api_keys") {
+				const idPredicate = eq(getDrizzleColumn(apiKeys, "id"), selector.value);
+				await db.update(apiKeys).set(input.update).where(idPredicate).execute();
+				return await db.query.api_keys.findFirst({ where: idPredicate }) ?? null;
+			}
+			if (input.model === "releases") {
+				const idPredicate = eq(getDrizzleColumn(releases, "id"), selector.value);
+				await db.update(releases).set(toStoredReleaseUpdate(input.update, provider)).where(idPredicate).execute();
+				const row = await db.query.releases.findFirst({ where: idPredicate });
+				return row === void 0 ? null : fromStoredReleaseRow(row);
+			}
+			if (input.model === "release_catalogs") {
+				const scopePredicate = eq(getDrizzleColumn(releaseCatalogs, "scope_key"), selector.value);
+				await db.update(releaseCatalogs).set(input.update).where(scopePredicate).execute();
+				const row = await db.query.release_catalogs.findFirst({ where: scopePredicate });
+				return row === void 0 ? null : fromStoredReleaseCatalogRow(row);
+			}
+			const idPredicate = eq(getDrizzleColumn(bundles, "id"), selector.value);
+			await db.update(bundles).set(toStoredBundleUpdate(input.update, provider)).where(idPredicate).execute();
+			const stored = await db.query.bundles.findFirst({ where: idPredicate });
+			if (stored === void 0) return null;
+			return fromStoredBundleRow(stored);
+		},
+		async delete(input) {
+			switch (input.model) {
+				case "bundles": {
+					const where = buildDrizzleWhere(provider, bundles, input.where);
+					if (where === void 0) throw new DrizzleAdapterInvariantError();
+					await db.delete(bundles).where(where).execute();
+					return;
+				}
+				case "bundle_patches": {
+					const where = buildDrizzleWhere(provider, patches, input.where);
+					if (where === void 0) throw new DrizzleAdapterInvariantError();
+					await db.delete(patches).where(where).execute();
+					return;
+				}
+				case "releases": {
+					const where = buildDrizzleWhere(provider, releases, input.where);
+					if (where === void 0) throw new DrizzleAdapterInvariantError();
+					await db.delete(releases).where(where).execute();
+					return;
+				}
+				case "channels": {
+					const where = buildDrizzleWhere(provider, channels, input.where);
+					if (where === void 0) throw new DrizzleAdapterInvariantError();
+					try {
+						await db.delete(channels).where(where).execute();
+					} catch (error) {
+						translateChannelDeleteError(error);
+					}
+					return;
+				}
+			}
+		},
+		async count(input) {
+			if (input.distinct !== void 0) throw new DatabasePluginInputError("invalid-operation");
+			switch (input.model) {
+				case "bundles": return db.$count(bundles, buildDrizzleWhere(provider, bundles, input.where));
+				case "bundle_patches": return db.$count(patches, buildDrizzleWhere(provider, patches, input.where));
+				case "releases": return db.$count(releases, buildDrizzleWhere(provider, releases, input.where));
+			}
+		},
+		async findOne(input) {
+			switch (input.model) {
+				case "bundles": {
+					const row = await db.query.bundles.findFirst({ where: buildDrizzleWhere(provider, bundles, input.where) });
+					return row === void 0 ? null : fromStoredBundleRow(row);
+				}
+				case "bundle_patches": return await db.query.bundle_patches.findFirst({ where: buildDrizzleWhere(provider, patches, input.where) }) ?? null;
+				case "api_keys": return await db.query.api_keys.findFirst({ where: buildDrizzleWhere(provider, apiKeys, input.where) }) ?? null;
+				case "channels": return await db.query.channels.findFirst({ where: buildDrizzleWhere(provider, channels, input.where) }) ?? null;
+				case "releases": {
+					const row = await db.query.releases.findFirst({ where: buildDrizzleWhere(provider, releases, input.where) });
+					return row === void 0 ? null : fromStoredReleaseRow(row);
+				}
+				case "release_catalogs": {
+					const row = await db.query.release_catalogs.findFirst({ where: buildDrizzleWhere(provider, releaseCatalogs, input.where) });
+					return row === void 0 ? null : fromStoredReleaseCatalogRow(row);
+				}
+			}
+		},
+		async findMany(input) {
+			if (input.distinctOn !== void 0) throw new DatabasePluginInputError("invalid-operation");
+			switch (input.model) {
+				case "bundles": return (await db.query.bundles.findMany({
+					where: buildDrizzleWhere(provider, bundles, input.where),
+					orderBy: toOrderBy(bundles, input),
+					limit: input.limit,
+					offset: input.offset
+				})).map(fromStoredBundleRow);
+				case "bundle_events": return db.query.bundle_events.findMany({
+					where: buildDrizzleWhere(provider, events, input.where),
+					orderBy: toOrderBy(events, input),
+					limit: input.limit,
+					offset: input.offset
+				});
+				case "api_keys": return db.query.api_keys.findMany({
+					where: buildDrizzleWhere(provider, apiKeys, input.where),
+					orderBy: toOrderBy(apiKeys, input),
+					limit: input.limit,
+					offset: input.offset
+				});
+				case "bundle_patches": return db.query.bundle_patches.findMany({
+					where: buildDrizzleWhere(provider, patches, input.where),
+					orderBy: toOrderBy(patches, input),
+					limit: input.limit,
+					offset: input.offset
+				});
+				case "channels": return db.query.channels.findMany({
+					where: buildDrizzleWhere(provider, channels, input.where),
+					orderBy: toOrderBy(channels, input),
+					limit: input.limit,
+					offset: input.offset
+				});
+				case "releases": return (await db.query.releases.findMany({
+					where: buildDrizzleWhere(provider, releases, input.where),
+					orderBy: toOrderBy(releases, input),
+					limit: input.limit,
+					offset: input.offset
+				})).map(fromStoredReleaseRow);
+				case "release_catalogs": return (await db.query.release_catalogs.findMany({
+					where: buildDrizzleWhere(provider, releaseCatalogs, input.where),
+					orderBy: toOrderBy(releaseCatalogs, input),
+					limit: input.limit,
+					offset: input.offset
+				})).map(fromStoredReleaseCatalogRow);
+			}
+		}
+	};
+};
+//#endregion
+export { createDrizzleCrud };

package/dist/adapters/drizzleLazyDB.cjs

@@ -1,52 +1,100 @@
 //#region src/adapters/drizzleLazyDB.ts
+var InvalidDrizzleDatabaseError = class extends Error {
+	name = "InvalidDrizzleDatabaseError";
+	constructor(reason) {
+		super(`[hot-updater] ${reason}`);
+		this.reason = reason;
+	}
+};
+const isRecord = (value) => typeof value === "object" && value !== null;
+const hasFunction = (value, key) => typeof value[key] === "function";
+const isDrizzleQuery = (value) => isRecord(value) && hasFunction(value, "findFirst") && hasFunction(value, "findMany");
+const isDrizzleDB = (value) => {
+	if (!isRecord(value)) return false;
+	const metadata = value["_"];
+	if (!isRecord(metadata) || !isRecord(metadata["fullSchema"])) return false;
+	const query = value["query"];
+	if (!isRecord(query) || !isDrizzleQuery(query["bundle_events"]) || !isDrizzleQuery(query["bundle_patches"]) || !isDrizzleQuery(query["bundles"]) || !isDrizzleQuery(query["channels"]) || !isDrizzleQuery(query["api_keys"]) || !isDrizzleQuery(query["releases"]) || !isDrizzleQuery(query["release_catalogs"])) return false;
+	if (value["transaction"] !== void 0 && !hasFunction(value, "transaction")) return false;
+	return hasFunction(value, "$count") && hasFunction(value, "delete") && hasFunction(value, "insert") && hasFunction(value, "update");
+};
 const asDB = (db) => {
-	const typed = db;
-	if (!typed._?.fullSchema) throw new Error("[hot-updater] Drizzle adapter requires query mode with schema.");
-	return typed;
+	if (!isDrizzleDB(db)) throw new InvalidDrizzleDatabaseError("Drizzle adapter requires query mode with schema.");
+	return db;
 };
 const isDBFactory = (db) => typeof db === "function";
+const parseSchema = (schema) => {
+	const parsed = {};
+	for (const [name, table] of Object.entries(schema)) {
+		if (!isRecord(table)) throw new InvalidDrizzleDatabaseError(`Drizzle schema table "${name}" is invalid.`);
+		parsed[name] = table;
+	}
+	return parsed;
+};
 const createLazyDB = (config) => {
-	const dbSource = config.db;
-	if (!isDBFactory(dbSource)) return asDB(dbSource);
-	if (!config.schema) throw new Error("[hot-updater] Drizzle adapter requires schema when db is lazy.");
+	if (!isDBFactory(config.db)) return asDB(config.db);
+	if (!config.schema) throw new InvalidDrizzleDatabaseError("Drizzle adapter requires schema when db is lazy.");
+	const source = config.db;
 	let resolvedDB;
-	const getDB = async () => {
-		resolvedDB ??= Promise.resolve(dbSource()).then(asDB);
+	const getDB = () => {
+		resolvedDB ??= Promise.resolve(source()).then(asDB);
 		return resolvedDB;
 	};
-	const fullSchema = config.schema;
-	const runInserted = async (table, value, operation) => {
-		return operation((await getDB()).insert(table).values(value));
-	};
 	return {
-		_: { fullSchema },
+		_: { fullSchema: parseSchema(config.schema) },
 		$count: async (table, where) => (await getDB()).$count(table, where),
-		delete: (table) => ({ where: async (condition) => (await getDB()).delete(table).where(condition) }),
-		insert: (table) => ({ values: (value) => ({
-			execute: async () => runInserted(table, value, async (inserted) => {
-				if (typeof inserted.execute === "function") return inserted.execute();
-				return inserted;
-			}),
-			onConflictDoUpdate: async (args) => runInserted(table, value, async (inserted) => {
-				if (typeof inserted.onConflictDoUpdate !== "function") throw new Error("[hot-updater] Drizzle insert does not support onConflictDoUpdate.");
-				return inserted.onConflictDoUpdate(args);
-			}),
-			onDuplicateKeyUpdate: async (args) => runInserted(table, value, async (inserted) => {
-				if (typeof inserted.onDuplicateKeyUpdate !== "function") throw new Error("[hot-updater] Drizzle insert does not support onDuplicateKeyUpdate.");
-				return inserted.onDuplicateKeyUpdate(args);
+		delete: (table) => ({ where: (condition) => ({ execute: async () => (await getDB()).delete(table).where(condition).execute() }) }),
+		insert: (table) => ({
+			ignore: () => ({ values: (value) => ({ execute: async () => {
+				const insert = (await getDB()).insert(table).ignore;
+				if (insert === void 0) throw new InvalidDrizzleDatabaseError("The resolved Drizzle database does not support insert ignore.");
+				return insert().values(value).execute();
+			} }) }),
+			values: (value) => ({
+				execute: async () => (await getDB()).insert(table).values(value).execute(),
+				onConflictDoNothing: () => ({ execute: async () => {
+					const insert = (await getDB()).insert(table).values(value);
+					if (insert.onConflictDoNothing === void 0) throw new InvalidDrizzleDatabaseError("The resolved Drizzle database does not support conflict-ignore inserts.");
+					return insert.onConflictDoNothing().execute();
+				} })
 			})
-		}) }),
-		query: new Proxy({}, { get: (_target, tableName) => ({
-			findFirst: async (args) => (await getDB()).query[String(tableName)]?.findFirst(args),
-			findMany: async (args) => (await getDB()).query[String(tableName)]?.findMany(args) ?? []
-		}) }),
-		select: (fields) => ({ from: (table) => ({ offset: async (offset) => (await getDB()).select(fields).from(table).offset?.(offset) ?? [] }) }),
-		update: (table) => ({ set: (values) => ({ where: async (condition) => (await getDB()).update(table).set(values).where(condition) }) }),
-		transaction: async (operation) => {
+		}),
+		query: {
+			bundle_events: {
+				findFirst: async (args) => (await getDB()).query.bundle_events.findFirst(args),
+				findMany: async (args) => (await getDB()).query.bundle_events.findMany(args)
+			},
+			bundle_patches: {
+				findFirst: async (args) => (await getDB()).query.bundle_patches.findFirst(args),
+				findMany: async (args) => (await getDB()).query.bundle_patches.findMany(args)
+			},
+			bundles: {
+				findFirst: async (args) => (await getDB()).query.bundles.findFirst(args),
+				findMany: async (args) => (await getDB()).query.bundles.findMany(args)
+			},
+			channels: {
+				findFirst: async (args) => (await getDB()).query.channels.findFirst(args),
+				findMany: async (args) => (await getDB()).query.channels.findMany(args)
+			},
+			api_keys: {
+				findFirst: async (args) => (await getDB()).query.api_keys.findFirst(args),
+				findMany: async (args) => (await getDB()).query.api_keys.findMany(args)
+			},
+			releases: {
+				findFirst: async (args) => (await getDB()).query.releases.findFirst(args),
+				findMany: async (args) => (await getDB()).query.releases.findMany(args)
+			},
+			release_catalogs: {
+				findFirst: async (args) => (await getDB()).query.release_catalogs.findFirst(args),
+				findMany: async (args) => (await getDB()).query.release_catalogs.findMany(args)
+			}
+		},
+		update: (table) => ({ set: (values) => ({ where: (condition) => ({ execute: async () => (await getDB()).update(table).set(values).where(condition).execute() }) }) }),
+		...config.transaction === true ? { transaction: async (operation) => {
 			const db = await getDB();
-			if (typeof db.transaction !== "function") return operation(db);
+			if (db.transaction === void 0) throw new InvalidDrizzleDatabaseError("The resolved Drizzle database does not support transactions.");
 			return db.transaction(operation);
-		}
+		} } : {}
 	};
 };
 //#endregion

package/dist/adapters/drizzleLazyDB.mjs

@@ -1,52 +1,100 @@
 //#region src/adapters/drizzleLazyDB.ts
+var InvalidDrizzleDatabaseError = class extends Error {
+	name = "InvalidDrizzleDatabaseError";
+	constructor(reason) {
+		super(`[hot-updater] ${reason}`);
+		this.reason = reason;
+	}
+};
+const isRecord = (value) => typeof value === "object" && value !== null;
+const hasFunction = (value, key) => typeof value[key] === "function";
+const isDrizzleQuery = (value) => isRecord(value) && hasFunction(value, "findFirst") && hasFunction(value, "findMany");
+const isDrizzleDB = (value) => {
+	if (!isRecord(value)) return false;
+	const metadata = value["_"];
+	if (!isRecord(metadata) || !isRecord(metadata["fullSchema"])) return false;
+	const query = value["query"];
+	if (!isRecord(query) || !isDrizzleQuery(query["bundle_events"]) || !isDrizzleQuery(query["bundle_patches"]) || !isDrizzleQuery(query["bundles"]) || !isDrizzleQuery(query["channels"]) || !isDrizzleQuery(query["api_keys"]) || !isDrizzleQuery(query["releases"]) || !isDrizzleQuery(query["release_catalogs"])) return false;
+	if (value["transaction"] !== void 0 && !hasFunction(value, "transaction")) return false;
+	return hasFunction(value, "$count") && hasFunction(value, "delete") && hasFunction(value, "insert") && hasFunction(value, "update");
+};
 const asDB = (db) => {
-	const typed = db;
-	if (!typed._?.fullSchema) throw new Error("[hot-updater] Drizzle adapter requires query mode with schema.");
-	return typed;
+	if (!isDrizzleDB(db)) throw new InvalidDrizzleDatabaseError("Drizzle adapter requires query mode with schema.");
+	return db;
 };
 const isDBFactory = (db) => typeof db === "function";
+const parseSchema = (schema) => {
+	const parsed = {};
+	for (const [name, table] of Object.entries(schema)) {
+		if (!isRecord(table)) throw new InvalidDrizzleDatabaseError(`Drizzle schema table "${name}" is invalid.`);
+		parsed[name] = table;
+	}
+	return parsed;
+};
 const createLazyDB = (config) => {
-	const dbSource = config.db;
-	if (!isDBFactory(dbSource)) return asDB(dbSource);
-	if (!config.schema) throw new Error("[hot-updater] Drizzle adapter requires schema when db is lazy.");
+	if (!isDBFactory(config.db)) return asDB(config.db);
+	if (!config.schema) throw new InvalidDrizzleDatabaseError("Drizzle adapter requires schema when db is lazy.");
+	const source = config.db;
 	let resolvedDB;
-	const getDB = async () => {
-		resolvedDB ??= Promise.resolve(dbSource()).then(asDB);
+	const getDB = () => {
+		resolvedDB ??= Promise.resolve(source()).then(asDB);
 		return resolvedDB;
 	};
-	const fullSchema = config.schema;
-	const runInserted = async (table, value, operation) => {
-		return operation((await getDB()).insert(table).values(value));
-	};
 	return {
-		_: { fullSchema },
+		_: { fullSchema: parseSchema(config.schema) },
 		$count: async (table, where) => (await getDB()).$count(table, where),
-		delete: (table) => ({ where: async (condition) => (await getDB()).delete(table).where(condition) }),
-		insert: (table) => ({ values: (value) => ({
-			execute: async () => runInserted(table, value, async (inserted) => {
-				if (typeof inserted.execute === "function") return inserted.execute();
-				return inserted;
-			}),
-			onConflictDoUpdate: async (args) => runInserted(table, value, async (inserted) => {
-				if (typeof inserted.onConflictDoUpdate !== "function") throw new Error("[hot-updater] Drizzle insert does not support onConflictDoUpdate.");
-				return inserted.onConflictDoUpdate(args);
-			}),
-			onDuplicateKeyUpdate: async (args) => runInserted(table, value, async (inserted) => {
-				if (typeof inserted.onDuplicateKeyUpdate !== "function") throw new Error("[hot-updater] Drizzle insert does not support onDuplicateKeyUpdate.");
-				return inserted.onDuplicateKeyUpdate(args);
+		delete: (table) => ({ where: (condition) => ({ execute: async () => (await getDB()).delete(table).where(condition).execute() }) }),
+		insert: (table) => ({
+			ignore: () => ({ values: (value) => ({ execute: async () => {
+				const insert = (await getDB()).insert(table).ignore;
+				if (insert === void 0) throw new InvalidDrizzleDatabaseError("The resolved Drizzle database does not support insert ignore.");
+				return insert().values(value).execute();
+			} }) }),
+			values: (value) => ({
+				execute: async () => (await getDB()).insert(table).values(value).execute(),
+				onConflictDoNothing: () => ({ execute: async () => {
+					const insert = (await getDB()).insert(table).values(value);
+					if (insert.onConflictDoNothing === void 0) throw new InvalidDrizzleDatabaseError("The resolved Drizzle database does not support conflict-ignore inserts.");
+					return insert.onConflictDoNothing().execute();
+				} })
 			})
-		}) }),
-		query: new Proxy({}, { get: (_target, tableName) => ({
-			findFirst: async (args) => (await getDB()).query[String(tableName)]?.findFirst(args),
-			findMany: async (args) => (await getDB()).query[String(tableName)]?.findMany(args) ?? []
-		}) }),
-		select: (fields) => ({ from: (table) => ({ offset: async (offset) => (await getDB()).select(fields).from(table).offset?.(offset) ?? [] }) }),
-		update: (table) => ({ set: (values) => ({ where: async (condition) => (await getDB()).update(table).set(values).where(condition) }) }),
-		transaction: async (operation) => {
+		}),
+		query: {
+			bundle_events: {
+				findFirst: async (args) => (await getDB()).query.bundle_events.findFirst(args),
+				findMany: async (args) => (await getDB()).query.bundle_events.findMany(args)
+			},
+			bundle_patches: {
+				findFirst: async (args) => (await getDB()).query.bundle_patches.findFirst(args),
+				findMany: async (args) => (await getDB()).query.bundle_patches.findMany(args)
+			},
+			bundles: {
+				findFirst: async (args) => (await getDB()).query.bundles.findFirst(args),
+				findMany: async (args) => (await getDB()).query.bundles.findMany(args)
+			},
+			channels: {
+				findFirst: async (args) => (await getDB()).query.channels.findFirst(args),
+				findMany: async (args) => (await getDB()).query.channels.findMany(args)
+			},
+			api_keys: {
+				findFirst: async (args) => (await getDB()).query.api_keys.findFirst(args),
+				findMany: async (args) => (await getDB()).query.api_keys.findMany(args)
+			},
+			releases: {
+				findFirst: async (args) => (await getDB()).query.releases.findFirst(args),
+				findMany: async (args) => (await getDB()).query.releases.findMany(args)
+			},
+			release_catalogs: {
+				findFirst: async (args) => (await getDB()).query.release_catalogs.findFirst(args),
+				findMany: async (args) => (await getDB()).query.release_catalogs.findMany(args)
+			}
+		},
+		update: (table) => ({ set: (values) => ({ where: (condition) => ({ execute: async () => (await getDB()).update(table).set(values).where(condition).execute() }) }) }),
+		...config.transaction === true ? { transaction: async (operation) => {
 			const db = await getDB();
-			if (typeof db.transaction !== "function") return operation(db);
+			if (db.transaction === void 0) throw new InvalidDrizzleDatabaseError("The resolved Drizzle database does not support transactions.");
 			return db.transaction(operation);
-		}
+		} } : {}
 	};
 };
 //#endregion

package/dist/adapters/drizzleQuery.cjs

@@ -0,0 +1,68 @@
+require("../_virtual/_rolldown/runtime.cjs");
+const require_databasePluginUtils = require("./databasePluginUtils.cjs");
+let drizzle_orm = require("drizzle-orm");
+//#region src/adapters/drizzleQuery.ts
+var InvalidDatabasePredicateError = class extends Error {
+	name = "InvalidDatabasePredicateError";
+};
+var MissingDrizzleColumnError = class extends Error {
+	name = "MissingDrizzleColumnError";
+	constructor(column) {
+		super(`Drizzle schema is missing column "${column}".`);
+		this.column = column;
+	}
+};
+const isSQLWrapper = (value) => typeof value === "object" && value !== null && "getSQL" in value && typeof value.getSQL === "function";
+const column = (table, field) => {
+	const value = table[field];
+	if (!isSQLWrapper(value)) throw new MissingDrizzleColumnError(field);
+	return value;
+};
+const stringPredicate = (provider, field, operator, value, insensitive) => {
+	if (provider === "sqlite" && !insensitive) {
+		const literal = require_databasePluginUtils.escapeGlobPattern(value);
+		return drizzle_orm.sql`${field} glob ${operator === "contains" ? `*${literal}*` : operator === "starts_with" ? `${literal}*` : `*${literal}`}`;
+	}
+	const literal = require_databasePluginUtils.escapeLikePattern(value);
+	const pattern = operator === "contains" ? `%${literal}%` : operator === "starts_with" ? `${literal}%` : `%${literal}`;
+	if (insensitive) return drizzle_orm.sql`lower(${field}) like lower(${pattern}) escape '\\'`;
+	if (provider === "mysql") return drizzle_orm.sql`binary ${field} like binary ${pattern} escape '\\'`;
+	return drizzle_orm.sql`${field} like ${pattern} escape '\\'`;
+};
+const predicate = (provider, table, condition) => {
+	const field = column(table, condition.field);
+	const operator = condition.operator ?? "eq";
+	switch (operator) {
+		case "eq":
+		case "ne":
+			if (condition.value === null) return operator === "eq" ? (0, drizzle_orm.isNull)(field) : (0, drizzle_orm.isNotNull)(field);
+			if ("mode" in condition && condition.mode === "insensitive") return operator === "eq" ? drizzle_orm.sql`lower(${field}) = lower(${condition.value})` : drizzle_orm.sql`lower(${field}) <> lower(${condition.value})`;
+			return operator === "eq" ? (0, drizzle_orm.eq)(field, condition.value) : (0, drizzle_orm.ne)(field, condition.value);
+		case "gt": return (0, drizzle_orm.gt)(field, condition.value);
+		case "gte": return (0, drizzle_orm.gte)(field, condition.value);
+		case "lt": return (0, drizzle_orm.lt)(field, condition.value);
+		case "lte": return (0, drizzle_orm.lte)(field, condition.value);
+		case "in":
+		case "not_in":
+			if (!Array.isArray(condition.value)) throw new InvalidDatabasePredicateError();
+			if (operator === "in") return condition.value.length === 0 ? drizzle_orm.sql`false` : (0, drizzle_orm.inArray)(field, condition.value);
+			return condition.value.length === 0 ? drizzle_orm.sql`true` : (0, drizzle_orm.notInArray)(field, condition.value);
+		case "contains":
+		case "starts_with":
+		case "ends_with":
+			if (typeof condition.value !== "string") throw new InvalidDatabasePredicateError();
+			return stringPredicate(provider, field, operator, condition.value, "mode" in condition && condition.mode === "insensitive");
+	}
+};
+const buildDrizzleWhere = (provider, table, where) => {
+	const [first, ...rest] = Array.isArray(where) ? where : [];
+	if (first === void 0) return void 0;
+	let expression = predicate(provider, table, first);
+	for (const condition of rest) {
+		const next = predicate(provider, table, condition);
+		expression = condition.connector === "OR" ? drizzle_orm.sql`(${expression} or ${next})` : drizzle_orm.sql`(${expression} and ${next})`;
+	}
+	return expression;
+};
+//#endregion
+exports.buildDrizzleWhere = buildDrizzleWhere;

package/dist/adapters/drizzleQuery.mjs

@@ -0,0 +1,67 @@
+import { escapeGlobPattern, escapeLikePattern } from "./databasePluginUtils.mjs";
+import { eq, gt, gte, inArray, isNotNull, isNull, lt, lte, ne, notInArray, sql } from "drizzle-orm";
+//#region src/adapters/drizzleQuery.ts
+var InvalidDatabasePredicateError = class extends Error {
+	name = "InvalidDatabasePredicateError";
+};
+var MissingDrizzleColumnError = class extends Error {
+	name = "MissingDrizzleColumnError";
+	constructor(column) {
+		super(`Drizzle schema is missing column "${column}".`);
+		this.column = column;
+	}
+};
+const isSQLWrapper = (value) => typeof value === "object" && value !== null && "getSQL" in value && typeof value.getSQL === "function";
+const column = (table, field) => {
+	const value = table[field];
+	if (!isSQLWrapper(value)) throw new MissingDrizzleColumnError(field);
+	return value;
+};
+const stringPredicate = (provider, field, operator, value, insensitive) => {
+	if (provider === "sqlite" && !insensitive) {
+		const literal = escapeGlobPattern(value);
+		return sql`${field} glob ${operator === "contains" ? `*${literal}*` : operator === "starts_with" ? `${literal}*` : `*${literal}`}`;
+	}
+	const literal = escapeLikePattern(value);
+	const pattern = operator === "contains" ? `%${literal}%` : operator === "starts_with" ? `${literal}%` : `%${literal}`;
+	if (insensitive) return sql`lower(${field}) like lower(${pattern}) escape '\\'`;
+	if (provider === "mysql") return sql`binary ${field} like binary ${pattern} escape '\\'`;
+	return sql`${field} like ${pattern} escape '\\'`;
+};
+const predicate = (provider, table, condition) => {
+	const field = column(table, condition.field);
+	const operator = condition.operator ?? "eq";
+	switch (operator) {
+		case "eq":
+		case "ne":
+			if (condition.value === null) return operator === "eq" ? isNull(field) : isNotNull(field);
+			if ("mode" in condition && condition.mode === "insensitive") return operator === "eq" ? sql`lower(${field}) = lower(${condition.value})` : sql`lower(${field}) <> lower(${condition.value})`;
+			return operator === "eq" ? eq(field, condition.value) : ne(field, condition.value);
+		case "gt": return gt(field, condition.value);
+		case "gte": return gte(field, condition.value);
+		case "lt": return lt(field, condition.value);
+		case "lte": return lte(field, condition.value);
+		case "in":
+		case "not_in":
+			if (!Array.isArray(condition.value)) throw new InvalidDatabasePredicateError();
+			if (operator === "in") return condition.value.length === 0 ? sql`false` : inArray(field, condition.value);
+			return condition.value.length === 0 ? sql`true` : notInArray(field, condition.value);
+		case "contains":
+		case "starts_with":
+		case "ends_with":
+			if (typeof condition.value !== "string") throw new InvalidDatabasePredicateError();
+			return stringPredicate(provider, field, operator, condition.value, "mode" in condition && condition.mode === "insensitive");
+	}
+};
+const buildDrizzleWhere = (provider, table, where) => {
+	const [first, ...rest] = Array.isArray(where) ? where : [];
+	if (first === void 0) return void 0;
+	let expression = predicate(provider, table, first);
+	for (const condition of rest) {
+		const next = predicate(provider, table, condition);
+		expression = condition.connector === "OR" ? sql`(${expression} or ${next})` : sql`(${expression} and ${next})`;
+	}
+	return expression;
+};
+//#endregion
+export { buildDrizzleWhere };