@hot-updater/server 0.33.1 → 0.34.0

package/dist/_virtual/_rolldown/runtime.cjs

@@ -5,7 +5,6 @@ var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __commonJSMin = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
 var __copyProps = (to, from, except, desc) => {
 	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
 		key = keys[i];
@@ -21,5 +20,4 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 	enumerable: true
 }) : target, mod));
 //#endregion
-exports.__commonJSMin = __commonJSMin;
 exports.__toESM = __toESM;

package/dist/adapters/drizzle.cjs

@@ -1,6 +1,199 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_index = require("../node_modules/.pnpm/fumadb@0.2.2_mongodb@6.20.0_@aws-sdk_credential-providers@3.1066.0_socks@2.8.9__prisma@_ee79457f0e32f18f0beb5c2db02e4f73/node_modules/fumadb/dist/adapters/drizzle/index.cjs");
+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_drizzleLazyDB = require("./drizzleLazyDB.cjs");
+let _hot_updater_plugin_core = require("@hot-updater/plugin-core");
+let _hot_updater_core = require("@hot-updater/core");
+let drizzle_orm = require("drizzle-orm");
 //#region src/adapters/drizzle.ts
-const drizzleAdapter = (config) => Object.assign(require_index.drizzleAdapter(config), { provider: config.provider });
+const getTable = (db, name) => {
+	const table = db._.fullSchema[name];
+	if (!table) throw new Error(`Drizzle schema is missing table "${name}".`);
+	return table;
+};
+const column = (table, name) => table[name];
+const buildWhere = (table, where) => {
+	const conditions = [];
+	if (where?.channel !== void 0) conditions.push((0, drizzle_orm.eq)(column(table, "channel"), where.channel));
+	if (where?.platform !== void 0) conditions.push((0, drizzle_orm.eq)(column(table, "platform"), where.platform));
+	if (where?.enabled !== void 0) conditions.push((0, drizzle_orm.eq)(column(table, "enabled"), where.enabled));
+	if (where?.fingerprintHash !== void 0) conditions.push(where.fingerprintHash === null ? (0, drizzle_orm.isNull)(column(table, "fingerprint_hash")) : (0, drizzle_orm.eq)(column(table, "fingerprint_hash"), where.fingerprintHash));
+	if (where?.targetAppVersion !== void 0) conditions.push(where.targetAppVersion === null ? (0, drizzle_orm.isNull)(column(table, "target_app_version")) : (0, drizzle_orm.eq)(column(table, "target_app_version"), where.targetAppVersion));
+	if (where?.targetAppVersionIn) conditions.push((0, drizzle_orm.inArray)(column(table, "target_app_version"), where.targetAppVersionIn));
+	if (where?.targetAppVersionNotNull) conditions.push((0, drizzle_orm.isNotNull)(column(table, "target_app_version")));
+	if (where?.id?.eq) conditions.push((0, drizzle_orm.eq)(column(table, "id"), where.id.eq));
+	if (where?.id?.gt) conditions.push((0, drizzle_orm.gt)(column(table, "id"), where.id.gt));
+	if (where?.id?.gte) conditions.push((0, drizzle_orm.gte)(column(table, "id"), where.id.gte));
+	if (where?.id?.lt) conditions.push((0, drizzle_orm.lt)(column(table, "id"), where.id.lt));
+	if (where?.id?.lte) conditions.push((0, drizzle_orm.lte)(column(table, "id"), where.id.lte));
+	if (where?.id?.in) conditions.push((0, drizzle_orm.inArray)(column(table, "id"), where.id.in));
+	return conditions.length > 0 ? (0, drizzle_orm.and)(...conditions) : void 0;
+};
+const createDrizzlePlugin = (0, _hot_updater_plugin_core.createDatabasePlugin)({
+	name: "drizzle",
+	factory: (config) => {
+		const db = require_drizzleLazyDB.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: (0, drizzle_orm.inArray)(column(patches, "bundle_id"), [...bundleIds]),
+				orderBy: [(0, drizzle_orm.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) => require_bundleRows.rowToBundle(row, patchMap.get(String(row["id"])) ?? []));
+		};
+		const upsertBundle = async (activeDB, bundle) => {
+			const row = require_bundleRows.bundleToRow(bundle);
+			if (await activeDB.query["bundles"]?.findFirst({ where: (0, drizzle_orm.eq)(column(bundles, "id"), bundle.id) })) await activeDB.update(bundles).set(row).where((0, drizzle_orm.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((0, drizzle_orm.eq)(column(patches, "bundle_id"), bundle.id));
+			const patchRows = require_bundleRows.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: (0, drizzle_orm.eq)(column(bundles, "id"), bundleId) });
+				if (!row) return null;
+				return require_bundleRows.rowToBundle(row, (await fetchPatchMap([bundleId])).get(bundleId) ?? []);
+			},
+			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" ? (0, drizzle_orm.asc)(column(bundles, "id")) : (0, drizzle_orm.desc)(column(bundles, "id"))],
+					limit: options.limit,
+					offset
+				}) ?? [];
+				const patchMap = await fetchPatchMap(dataRows.map((row) => String(row["id"])));
+				return {
+					data: dataRows.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) {
+				if (args._updateStrategy === "appVersion") {
+					const channel = args.channel ?? "production";
+					const minBundleId = args.minBundleId ?? _hot_updater_core.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 = (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 updateRows = compatibleAppVersions.length > 0 ? await db.query["bundles"]?.findMany({
+						where: buildWhere(bundles, {
+							enabled: true,
+							platform: args.platform,
+							channel,
+							id: { gte: minBundleId },
+							targetAppVersionIn: compatibleAppVersions
+						}),
+						orderBy: [(0, drizzle_orm.desc)(column(bundles, "id"))]
+					}) : [];
+					return (0, _hot_updater_plugin_core.resolveUpdateInfoFromBundles)({
+						args: {
+							...args,
+							channel,
+							minBundleId
+						},
+						bundles: await mapRowsToBundles(updateRows ?? []),
+						context
+					});
+				}
+				const channel = args.channel ?? "production";
+				const minBundleId = args.minBundleId ?? _hot_updater_core.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: [(0, drizzle_orm.desc)(column(bundles, "id"))]
+				});
+				return (0, _hot_updater_plugin_core.resolveUpdateInfoFromBundles)({
+					args: {
+						...args,
+						channel,
+						minBundleId
+					},
+					bundles: await mapRowsToBundles(rows ?? []),
+					context
+				});
+			},
+			async getChannels() {
+				const rows = await db.query["bundles"]?.findMany({
+					columns: { channel: true },
+					orderBy: [(0, drizzle_orm.asc)(column(bundles, "channel"))]
+				});
+				return Array.from(new Set((rows ?? []).map((row) => String(row["channel"]))));
+			},
+			async commitBundle({ changedSets }) {
+				await runInTransaction(async (activeDB) => {
+					for (const change of changedSets) {
+						if (change.operation === "delete") {
+							await activeDB.delete(patches).where((0, drizzle_orm.eq)(column(patches, "bundle_id"), change.data.id));
+							await activeDB.delete(patches).where((0, drizzle_orm.eq)(column(patches, "base_bundle_id"), change.data.id));
+							await activeDB.delete(bundles).where((0, drizzle_orm.eq)(column(bundles, "id"), change.data.id));
+							continue;
+						}
+						await upsertBundle(activeDB, change.data);
+					}
+				});
+			}
+		};
+	}
+});
+const drizzleAdapter = (config) => {
+	return Object.assign(createDrizzlePlugin(config), {
+		adapterName: "drizzle",
+		provider: config.provider,
+		generateSchema: (version) => ({
+			code: require_schemaGenerators.generateDrizzleSchema(config.provider, version === "latest" ? require_registry.hotUpdaterSchema : require_registry.getHotUpdaterSchemaVersion(version)),
+			path: "hot-updater-schema.ts"
+		})
+	});
+};
 //#endregion
 exports.drizzleAdapter = drizzleAdapter;

package/dist/adapters/drizzle.d.cts

@@ -1,8 +1,11 @@
-import { drizzleAdapter as drizzleAdapter$1 } from "../node_modules/.pnpm/fumadb@0.2.2_mongodb@6.20.0_@aws-sdk_credential-providers@3.1066.0_socks@2.8.9__prisma@_ee79457f0e32f18f0beb5c2db02e4f73/node_modules/fumadb/dist/adapters/drizzle/index.cjs";
-import { ORMDatabaseAdapter } from "../db/types.cjs";
+import { DatabasePluginFactory, ORMProvider } from "../db/types.cjs";
 
 //#region src/adapters/drizzle.d.ts
-type DrizzleConfig = Parameters<typeof drizzleAdapter$1>[0];
-declare const drizzleAdapter: (config: DrizzleConfig) => ORMDatabaseAdapter;
+interface DrizzleConfig {
+  readonly db: unknown | (() => unknown | Promise<unknown>);
+  readonly provider: Exclude<ORMProvider, "cockroachdb" | "mongodb" | "mssql">;
+  readonly schema?: Record<string, unknown>;
+}
+declare const drizzleAdapter: (config: DrizzleConfig) => DatabasePluginFactory;
 //#endregion
 export { DrizzleConfig, drizzleAdapter };

package/dist/adapters/drizzle.d.mts

@@ -1,8 +1,11 @@
-import { drizzleAdapter as drizzleAdapter$1 } from "../node_modules/.pnpm/fumadb@0.2.2_mongodb@6.20.0_@aws-sdk_credential-providers@3.1066.0_socks@2.8.9__prisma@_ee79457f0e32f18f0beb5c2db02e4f73/node_modules/fumadb/dist/adapters/drizzle/index.mjs";
-import { ORMDatabaseAdapter } from "../db/types.mjs";
+import { DatabasePluginFactory, ORMProvider } from "../db/types.mjs";
 
 //#region src/adapters/drizzle.d.ts
-type DrizzleConfig = Parameters<typeof drizzleAdapter$1>[0];
-declare const drizzleAdapter: (config: DrizzleConfig) => ORMDatabaseAdapter;
+interface DrizzleConfig {
+  readonly db: unknown | (() => unknown | Promise<unknown>);
+  readonly provider: Exclude<ORMProvider, "cockroachdb" | "mongodb" | "mssql">;
+  readonly schema?: Record<string, unknown>;
+}
+declare const drizzleAdapter: (config: DrizzleConfig) => DatabasePluginFactory;
 //#endregion
 export { DrizzleConfig, drizzleAdapter };

package/dist/adapters/drizzle.mjs

@@ -1,5 +1,197 @@
-import { drizzleAdapter as drizzleAdapter$1 } from "../node_modules/.pnpm/fumadb@0.2.2_mongodb@6.20.0_@aws-sdk_credential-providers@3.1066.0_socks@2.8.9__prisma@_ee79457f0e32f18f0beb5c2db02e4f73/node_modules/fumadb/dist/adapters/drizzle/index.mjs";
+import { getHotUpdaterSchemaVersion, hotUpdaterSchema } from "../db/schema/registry.mjs";
+import { generateDrizzleSchema } from "../db/schemaGenerators.mjs";
+import { bundleToPatchRows, bundleToRow, rowToBundle } from "../db/bundleRows.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";
 //#region src/adapters/drizzle.ts
-const drizzleAdapter = (config) => Object.assign(drizzleAdapter$1(config), { provider: config.provider });
+const getTable = (db, name) => {
+	const table = db._.fullSchema[name];
+	if (!table) throw new Error(`Drizzle schema is missing table "${name}".`);
+	return table;
+};
+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) ?? []);
+			},
+			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
+					})
+				};
+			},
+			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
+				});
+			},
+			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"]))));
+			},
+			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);
+					}
+				});
+			}
+		};
+	}
+});
+const drizzleAdapter = (config) => {
+	return Object.assign(createDrizzlePlugin(config), {
+		adapterName: "drizzle",
+		provider: config.provider,
+		generateSchema: (version) => ({
+			code: generateDrizzleSchema(config.provider, version === "latest" ? hotUpdaterSchema : getHotUpdaterSchemaVersion(version)),
+			path: "hot-updater-schema.ts"
+		})
+	});
+};
 //#endregion
 export { drizzleAdapter };

package/dist/adapters/drizzleLazyDB.cjs

@@ -0,0 +1,53 @@
+//#region src/adapters/drizzleLazyDB.ts
+const asDB = (db) => {
+	const typed = db;
+	if (!typed._?.fullSchema) throw new Error("[hot-updater] Drizzle adapter requires query mode with schema.");
+	return typed;
+};
+const isDBFactory = (db) => typeof db === "function";
+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.");
+	let resolvedDB;
+	const getDB = async () => {
+		resolvedDB ??= Promise.resolve(dbSource()).then(asDB);
+		return resolvedDB;
+	};
+	const fullSchema = config.schema;
+	const runInserted = async (table, value, operation) => {
+		return operation((await getDB()).insert(table).values(value));
+	};
+	return {
+		_: { fullSchema },
+		$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);
+			})
+		}) }),
+		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) => {
+			const db = await getDB();
+			if (typeof db.transaction !== "function") return operation(db);
+			return db.transaction(operation);
+		}
+	};
+};
+//#endregion
+exports.createLazyDB = createLazyDB;

package/dist/adapters/drizzleLazyDB.mjs

@@ -0,0 +1,53 @@
+//#region src/adapters/drizzleLazyDB.ts
+const asDB = (db) => {
+	const typed = db;
+	if (!typed._?.fullSchema) throw new Error("[hot-updater] Drizzle adapter requires query mode with schema.");
+	return typed;
+};
+const isDBFactory = (db) => typeof db === "function";
+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.");
+	let resolvedDB;
+	const getDB = async () => {
+		resolvedDB ??= Promise.resolve(dbSource()).then(asDB);
+		return resolvedDB;
+	};
+	const fullSchema = config.schema;
+	const runInserted = async (table, value, operation) => {
+		return operation((await getDB()).insert(table).values(value));
+	};
+	return {
+		_: { fullSchema },
+		$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);
+			})
+		}) }),
+		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) => {
+			const db = await getDB();
+			if (typeof db.transaction !== "function") return operation(db);
+			return db.transaction(operation);
+		}
+	};
+};
+//#endregion
+export { createLazyDB };