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

package/dist/adapters/drizzle.mjs

@@ -1,190 +1,67 @@
 import { getHotUpdaterSchemaVersion, hotUpdaterSchema } from "../db/schema/registry.mjs";
 import { generateDrizzleSchema } from "../db/schemaGenerators.mjs";
-import { bundleToPatchRows, bundleToRow, rowToBundle } from "../db/bundleRows.mjs";
+import { createDrizzleCrud } from "./drizzleCrud.mjs";
 import { createLazyDB } from "./drizzleLazyDB.mjs";
-import { calculatePagination, createDatabasePlugin, filterCompatibleAppVersions, resolveUpdateInfoFromBundles } from "@hot-updater/plugin-core";
-import { NIL_UUID } from "@hot-updater/core";
-import { and, asc, desc, eq, gt, gte, inArray, isNotNull, isNull, lt, lte } from "drizzle-orm";
+import { createDatabasePlugin } from "@hot-updater/plugin-core";
+import { createDatabasePluginAdapter } from "@hot-updater/plugin-core/internal";
 //#region src/adapters/drizzle.ts
-const getTable = (db, name) => {
-	const table = db._.fullSchema[name];
-	if (!table) throw new Error(`Drizzle schema is missing table "${name}".`);
-	return table;
+const createImplementation = (config) => {
+	const db = createLazyDB(config);
+	const crud = createDrizzleCrud(db, config.provider);
+	const transaction = db.transaction?.bind(db);
+	return {
+		...crud,
+		deleteChannel: (input) => {
+			if (transaction === void 0) throw new Error("Drizzle channel deletion requires transaction support.");
+			return transaction((transactionDatabase) => createDrizzleCrud(transactionDatabase, config.provider).deleteChannel(input));
+		},
+		...transaction ? { delete: (input) => transaction((transactionDatabase) => createDrizzleCrud(transactionDatabase, config.provider).delete(input)) } : {},
+		...transaction ? { transaction: async (callback) => transaction((transaction) => callback(createDrizzleCrud(transaction, config.provider))) } : {}
+	};
 };
-const column = (table, name) => table[name];
-const buildWhere = (table, where) => {
-	const conditions = [];
-	if (where?.channel !== void 0) conditions.push(eq(column(table, "channel"), where.channel));
-	if (where?.platform !== void 0) conditions.push(eq(column(table, "platform"), where.platform));
-	if (where?.enabled !== void 0) conditions.push(eq(column(table, "enabled"), where.enabled));
-	if (where?.fingerprintHash !== void 0) conditions.push(where.fingerprintHash === null ? isNull(column(table, "fingerprint_hash")) : eq(column(table, "fingerprint_hash"), where.fingerprintHash));
-	if (where?.targetAppVersion !== void 0) conditions.push(where.targetAppVersion === null ? isNull(column(table, "target_app_version")) : eq(column(table, "target_app_version"), where.targetAppVersion));
-	if (where?.targetAppVersionIn) conditions.push(inArray(column(table, "target_app_version"), where.targetAppVersionIn));
-	if (where?.targetAppVersionNotNull) conditions.push(isNotNull(column(table, "target_app_version")));
-	if (where?.id?.eq) conditions.push(eq(column(table, "id"), where.id.eq));
-	if (where?.id?.gt) conditions.push(gt(column(table, "id"), where.id.gt));
-	if (where?.id?.gte) conditions.push(gte(column(table, "id"), where.id.gte));
-	if (where?.id?.lt) conditions.push(lt(column(table, "id"), where.id.lt));
-	if (where?.id?.lte) conditions.push(lte(column(table, "id"), where.id.lte));
-	if (where?.id?.in) conditions.push(inArray(column(table, "id"), where.id.in));
-	return conditions.length > 0 ? and(...conditions) : void 0;
-};
-const createDrizzlePlugin = createDatabasePlugin({
-	name: "drizzle",
-	factory: (config) => {
-		const db = createLazyDB(config);
-		const bundles = getTable(db, "bundles");
-		const patches = getTable(db, "bundle_patches");
-		const runInTransaction = async (operation) => {
-			if (typeof db.transaction !== "function") return operation(db);
-			return db.transaction(operation);
-		};
-		const fetchPatchMap = async (bundleIds) => {
-			const patchMap = /* @__PURE__ */ new Map();
-			if (bundleIds.length === 0) return patchMap;
-			const rows = await db.query["bundle_patches"]?.findMany({
-				where: inArray(column(patches, "bundle_id"), [...bundleIds]),
-				orderBy: [asc(column(patches, "order_index"))]
-			});
-			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 mapRowsToBundles = async (rows) => {
-			const patchMap = await fetchPatchMap(rows.map((row) => String(row["id"])));
-			return rows.map((row) => rowToBundle(row, patchMap.get(String(row["id"])) ?? []));
-		};
-		const upsertBundle = async (activeDB, bundle) => {
-			const row = bundleToRow(bundle);
-			if (await activeDB.query["bundles"]?.findFirst({ where: eq(column(bundles, "id"), bundle.id) })) await activeDB.update(bundles).set(row).where(eq(column(bundles, "id"), bundle.id));
-			else {
-				const inserted = activeDB.insert(bundles).values(row);
-				if (inserted.execute) await inserted.execute();
-				else await inserted;
-			}
-			await activeDB.delete(patches).where(eq(column(patches, "bundle_id"), bundle.id));
-			const patchRows = bundleToPatchRows(bundle);
-			if (patchRows.length > 0) {
-				const inserted = activeDB.insert(patches).values(patchRows);
-				if (inserted.execute) await inserted.execute();
-				else await inserted;
-			}
-		};
-		return {
-			async getBundleById(bundleId) {
-				const row = await db.query["bundles"]?.findFirst({ where: eq(column(bundles, "id"), bundleId) });
-				if (!row) return null;
-				return rowToBundle(row, (await fetchPatchMap([bundleId])).get(bundleId) ?? []);
+const drizzleAdapter = (config) => {
+	let adapter;
+	const getAdapter = () => {
+		adapter ??= createDatabasePluginAdapter("drizzle", createImplementation(config));
+		return adapter;
+	};
+	const plugin = createDatabasePlugin({
+		name: "drizzle",
+		models: {
+			bundles: {
+				findById: (id) => getAdapter().models.bundles.findById(id),
+				findMany: (query) => getAdapter().models.bundles.findMany(query),
+				count: (where) => getAdapter().models.bundles.count(where)
+			},
+			bundlePatches: { findByBundleIds: (bundleIds) => getAdapter().models.bundlePatches.findByBundleIds(bundleIds) },
+			releases: {
+				findById: (id) => getAdapter().models.releases.findById(id),
+				findMany: (input) => getAdapter().models.releases.findMany(input),
+				findManyByScope: (input) => getAdapter().models.releases.findManyByScope(input)
 			},
-			async getBundles(options) {
-				const offset = options.offset ?? 0;
-				const orderBy = options.orderBy ?? {
-					field: "id",
-					direction: "desc"
-				};
-				const where = buildWhere(bundles, options.where);
-				const total = await db.$count(bundles, where);
-				const dataRows = await db.query["bundles"]?.findMany({
-					where,
-					orderBy: [orderBy.direction === "asc" ? asc(column(bundles, "id")) : desc(column(bundles, "id"))],
-					limit: options.limit,
-					offset
-				}) ?? [];
-				const patchMap = await fetchPatchMap(dataRows.map((row) => String(row["id"])));
-				return {
-					data: dataRows.map((row) => rowToBundle(row, patchMap.get(String(row["id"])) ?? [])),
-					pagination: calculatePagination(total, {
-						limit: options.limit,
-						offset
-					})
-				};
+			releaseCatalogs: {
+				findByScopeKey: (scopeKey) => getAdapter().models.releaseCatalogs.findByScopeKey(scopeKey),
+				findMany: (input) => getAdapter().models.releaseCatalogs.findMany(input)
 			},
-			async getUpdateInfo(args, context) {
-				if (args._updateStrategy === "appVersion") {
-					const channel = args.channel ?? "production";
-					const minBundleId = args.minBundleId ?? NIL_UUID;
-					const rows = await db.query["bundles"]?.findMany({
-						columns: { target_app_version: true },
-						where: buildWhere(bundles, {
-							enabled: true,
-							platform: args.platform,
-							channel,
-							id: { gte: minBundleId },
-							targetAppVersionNotNull: true
-						})
-					});
-					const compatibleAppVersions = filterCompatibleAppVersions(Array.from(new Set((rows ?? []).map((row) => row["target_app_version"]).filter((value) => typeof value === "string" && value.length > 0))), args.appVersion);
-					const updateRows = compatibleAppVersions.length > 0 ? await db.query["bundles"]?.findMany({
-						where: buildWhere(bundles, {
-							enabled: true,
-							platform: args.platform,
-							channel,
-							id: { gte: minBundleId },
-							targetAppVersionIn: compatibleAppVersions
-						}),
-						orderBy: [desc(column(bundles, "id"))]
-					}) : [];
-					return resolveUpdateInfoFromBundles({
-						args: {
-							...args,
-							channel,
-							minBundleId
-						},
-						bundles: await mapRowsToBundles(updateRows ?? []),
-						context
-					});
-				}
-				const channel = args.channel ?? "production";
-				const minBundleId = args.minBundleId ?? NIL_UUID;
-				const rows = await db.query["bundles"]?.findMany({
-					where: buildWhere(bundles, {
-						enabled: true,
-						platform: args.platform,
-						channel,
-						id: { gte: minBundleId },
-						fingerprintHash: args.fingerprintHash
-					}),
-					orderBy: [desc(column(bundles, "id"))]
-				});
-				return resolveUpdateInfoFromBundles({
-					args: {
-						...args,
-						channel,
-						minBundleId
-					},
-					bundles: await mapRowsToBundles(rows ?? []),
-					context
-				});
+			channels: {
+				insert: (input) => getAdapter().models.channels.insert(input),
+				list: (input) => getAdapter().models.channels.list(input),
+				delete: (input) => getAdapter().models.channels.delete(input)
 			},
-			async getChannels() {
-				const rows = await db.query["bundles"]?.findMany({
-					columns: { channel: true },
-					orderBy: [asc(column(bundles, "channel"))]
-				});
-				return Array.from(new Set((rows ?? []).map((row) => String(row["channel"]))));
+			analytics: {
+				append: (row) => getAdapter().models.analytics.append(row),
+				scan: (input) => getAdapter().models.analytics.scan(input)
 			},
-			async commitBundle({ changedSets }) {
-				await runInTransaction(async (activeDB) => {
-					for (const change of changedSets) {
-						if (change.operation === "delete") {
-							await activeDB.delete(patches).where(eq(column(patches, "bundle_id"), change.data.id));
-							await activeDB.delete(patches).where(eq(column(patches, "base_bundle_id"), change.data.id));
-							await activeDB.delete(bundles).where(eq(column(bundles, "id"), change.data.id));
-							continue;
-						}
-						await upsertBundle(activeDB, change.data);
-					}
-				});
+			apiKeys: {
+				create: (row) => getAdapter().models.apiKeys.create(row),
+				findByHash: (hash) => getAdapter().models.apiKeys.findByHash(hash),
+				list: () => getAdapter().models.apiKeys.list(),
+				revoke: (input) => getAdapter().models.apiKeys.revoke(input)
 			}
-		};
-	}
-});
-const drizzleAdapter = (config) => {
-	return Object.assign(createDrizzlePlugin(config), {
+		},
+		commit: (input) => getAdapter().commit(input)
+	});
+	return Object.assign(plugin, {
 		adapterName: "drizzle",
 		provider: config.provider,
 		generateSchema: (version) => ({

package/dist/adapters/drizzleCrud.cjs

@@ -0,0 +1,250 @@
+require("../_virtual/_rolldown/runtime.cjs");
+const require_databaseConstraintErrors = require("./databaseConstraintErrors.cjs");
+const require_databasePluginUtils = require("./databasePluginUtils.cjs");
+const require_drizzleQuery = require("./drizzleQuery.cjs");
+let _hot_updater_plugin_core = require("@hot-updater/plugin-core");
+let drizzle_orm = require("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" ? drizzle_orm.sql`${column} is null desc` : drizzle_orm.sql`${column} is null asc`, clause.direction === "asc" ? (0, drizzle_orm.asc)(column) : (0, drizzle_orm.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 = (0, drizzle_orm.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, (0, drizzle_orm.eq)(getDrizzleColumn(releases, "channel_id"), id)) > 0) return {
+				deleted: false,
+				reason: "not_empty"
+			};
+			try {
+				await db.delete(channels).where(idPredicate).execute();
+			} catch (error) {
+				if (require_databaseConstraintErrors.isChannelDeleteReferencedError(error)) return {
+					deleted: false,
+					reason: "not_empty"
+				};
+				throw error;
+			}
+			return { deleted: true };
+		},
+		async insertChannel(input) {
+			const before = await db.query.channels.findFirst({ where: (0, drizzle_orm.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: (0, drizzle_orm.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, require_databasePluginUtils.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, require_databasePluginUtils.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 = (0, drizzle_orm.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 = (0, drizzle_orm.eq)(getDrizzleColumn(releases, "id"), selector.value);
+				await db.update(releases).set(require_databasePluginUtils.toStoredReleaseUpdate(input.update, provider)).where(idPredicate).execute();
+				const row = await db.query.releases.findFirst({ where: idPredicate });
+				return row === void 0 ? null : require_databasePluginUtils.fromStoredReleaseRow(row);
+			}
+			if (input.model === "release_catalogs") {
+				const scopePredicate = (0, drizzle_orm.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 : require_databasePluginUtils.fromStoredReleaseCatalogRow(row);
+			}
+			const idPredicate = (0, drizzle_orm.eq)(getDrizzleColumn(bundles, "id"), selector.value);
+			await db.update(bundles).set(require_databasePluginUtils.toStoredBundleUpdate(input.update, provider)).where(idPredicate).execute();
+			const stored = await db.query.bundles.findFirst({ where: idPredicate });
+			if (stored === void 0) return null;
+			return require_databasePluginUtils.fromStoredBundleRow(stored);
+		},
+		async delete(input) {
+			switch (input.model) {
+				case "bundles": {
+					const where = require_drizzleQuery.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 = require_drizzleQuery.buildDrizzleWhere(provider, patches, input.where);
+					if (where === void 0) throw new DrizzleAdapterInvariantError();
+					await db.delete(patches).where(where).execute();
+					return;
+				}
+				case "releases": {
+					const where = require_drizzleQuery.buildDrizzleWhere(provider, releases, input.where);
+					if (where === void 0) throw new DrizzleAdapterInvariantError();
+					await db.delete(releases).where(where).execute();
+					return;
+				}
+				case "channels": {
+					const where = require_drizzleQuery.buildDrizzleWhere(provider, channels, input.where);
+					if (where === void 0) throw new DrizzleAdapterInvariantError();
+					try {
+						await db.delete(channels).where(where).execute();
+					} catch (error) {
+						require_databaseConstraintErrors.translateChannelDeleteError(error);
+					}
+					return;
+				}
+			}
+		},
+		async count(input) {
+			if (input.distinct !== void 0) throw new _hot_updater_plugin_core.DatabasePluginInputError("invalid-operation");
+			switch (input.model) {
+				case "bundles": return db.$count(bundles, require_drizzleQuery.buildDrizzleWhere(provider, bundles, input.where));
+				case "bundle_patches": return db.$count(patches, require_drizzleQuery.buildDrizzleWhere(provider, patches, input.where));
+				case "releases": return db.$count(releases, require_drizzleQuery.buildDrizzleWhere(provider, releases, input.where));
+			}
+		},
+		async findOne(input) {
+			switch (input.model) {
+				case "bundles": {
+					const row = await db.query.bundles.findFirst({ where: require_drizzleQuery.buildDrizzleWhere(provider, bundles, input.where) });
+					return row === void 0 ? null : require_databasePluginUtils.fromStoredBundleRow(row);
+				}
+				case "bundle_patches": return await db.query.bundle_patches.findFirst({ where: require_drizzleQuery.buildDrizzleWhere(provider, patches, input.where) }) ?? null;
+				case "api_keys": return await db.query.api_keys.findFirst({ where: require_drizzleQuery.buildDrizzleWhere(provider, apiKeys, input.where) }) ?? null;
+				case "channels": return await db.query.channels.findFirst({ where: require_drizzleQuery.buildDrizzleWhere(provider, channels, input.where) }) ?? null;
+				case "releases": {
+					const row = await db.query.releases.findFirst({ where: require_drizzleQuery.buildDrizzleWhere(provider, releases, input.where) });
+					return row === void 0 ? null : require_databasePluginUtils.fromStoredReleaseRow(row);
+				}
+				case "release_catalogs": {
+					const row = await db.query.release_catalogs.findFirst({ where: require_drizzleQuery.buildDrizzleWhere(provider, releaseCatalogs, input.where) });
+					return row === void 0 ? null : require_databasePluginUtils.fromStoredReleaseCatalogRow(row);
+				}
+			}
+		},
+		async findMany(input) {
+			if (input.distinctOn !== void 0) throw new _hot_updater_plugin_core.DatabasePluginInputError("invalid-operation");
+			switch (input.model) {
+				case "bundles": return (await db.query.bundles.findMany({
+					where: require_drizzleQuery.buildDrizzleWhere(provider, bundles, input.where),
+					orderBy: toOrderBy(bundles, input),
+					limit: input.limit,
+					offset: input.offset
+				})).map(require_databasePluginUtils.fromStoredBundleRow);
+				case "bundle_events": return db.query.bundle_events.findMany({
+					where: require_drizzleQuery.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: require_drizzleQuery.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: require_drizzleQuery.buildDrizzleWhere(provider, patches, input.where),
+					orderBy: toOrderBy(patches, input),
+					limit: input.limit,
+					offset: input.offset
+				});
+				case "channels": return db.query.channels.findMany({
+					where: require_drizzleQuery.buildDrizzleWhere(provider, channels, input.where),
+					orderBy: toOrderBy(channels, input),
+					limit: input.limit,
+					offset: input.offset
+				});
+				case "releases": return (await db.query.releases.findMany({
+					where: require_drizzleQuery.buildDrizzleWhere(provider, releases, input.where),
+					orderBy: toOrderBy(releases, input),
+					limit: input.limit,
+					offset: input.offset
+				})).map(require_databasePluginUtils.fromStoredReleaseRow);
+				case "release_catalogs": return (await db.query.release_catalogs.findMany({
+					where: require_drizzleQuery.buildDrizzleWhere(provider, releaseCatalogs, input.where),
+					orderBy: toOrderBy(releaseCatalogs, input),
+					limit: input.limit,
+					offset: input.offset
+				})).map(require_databasePluginUtils.fromStoredReleaseCatalogRow);
+			}
+		}
+	};
+};
+//#endregion
+exports.createDrizzleCrud = createDrizzleCrud;