@hot-updater/server 0.36.7 → 1.0.0-rc.1

package/dist/db/createBundleDiff.d.cts

@@ -1,4 +1,4 @@
-import { Bundle, DatabasePlugin, NodeStoragePlugin } from "@hot-updater/plugin-core";
+import { Bundle, BundleRepository, StoragePluginWith } from "@hot-updater/plugin-core";
 
 //#region src/db/createBundleDiff.d.ts
 interface CreateBundleDiffInput {
@@ -6,8 +6,8 @@ interface CreateBundleDiffInput {
   bundleId: string;
 }
 interface CreateBundleDiffDependencies {
-  databasePlugin: DatabasePlugin;
-  storagePlugin: NodeStoragePlugin | null;
+  databasePlugin: BundleRepository;
+  storagePlugin: StoragePluginWith<"get" | "put" | "delete"> | null;
 }
 interface CreateBundleDiffOptions {
   makePrimary?: boolean;

package/dist/db/createBundleDiff.d.mts

@@ -1,4 +1,4 @@
-import { Bundle, DatabasePlugin, NodeStoragePlugin } from "@hot-updater/plugin-core";
+import { Bundle, BundleRepository, StoragePluginWith } from "@hot-updater/plugin-core";
 
 //#region src/db/createBundleDiff.d.ts
 interface CreateBundleDiffInput {
@@ -6,8 +6,8 @@ interface CreateBundleDiffInput {
   bundleId: string;
 }
 interface CreateBundleDiffDependencies {
-  databasePlugin: DatabasePlugin;
-  storagePlugin: NodeStoragePlugin | null;
+  databasePlugin: BundleRepository;
+  storagePlugin: StoragePluginWith<"get" | "put" | "delete"> | null;
 }
 interface CreateBundleDiffOptions {
   makePrimary?: boolean;

package/dist/db/createBundleDiff.mjs

@@ -1,15 +1,12 @@
-import { createBundleStorageKey, getManifestAssetDownloadPath, resolveManifestAssetStorageUri } from "@hot-updater/plugin-core";
+import { createBundleStorageKey, createDatabaseClient, getManifestAssetDownloadPath, resolveManifestAssetStorageUri } from "@hot-updater/plugin-core";
 import { getAssetBaseStorageUri, getBundlePatch, getBundlePatches, getManifestStorageUri } from "@hot-updater/core";
-import crypto, { randomUUID } from "node:crypto";
-import fs from "node:fs/promises";
-import os from "node:os";
+import crypto from "node:crypto";
 import path from "node:path";
 import { promisify } from "node:util";
 import { brotliDecompress } from "node:zlib";
 import { hdiff } from "@hot-updater/bsdiff";
 //#region src/db/createBundleDiff.ts
 const HBC_ASSET_PATH_RE = /\.bundle$/;
-const HOT_UPDATER_DOWNLOAD_DIR_PREFIX = "downloads-";
 const decompressBrotli = promisify(brotliDecompress);
 const isBundleManifest = (value) => {
 	if (!value || typeof value !== "object" || Array.isArray(value)) return false;
@@ -34,23 +31,14 @@ async function downloadFromUrl(url) {
 }
 async function downloadStorageBytes(storageUri, storagePlugin) {
 	const protocol = new URL(storageUri).protocol.replace(":", "");
-	if (protocol === "http" || protocol === "https") return downloadFromUrl(storageUri);
-	if (!storagePlugin) throw new Error("Storage plugin is not configured");
-	if (storagePlugin.supportedProtocol !== protocol) throw new Error(`No storage plugin for protocol: ${protocol}`);
-	const downloadRoot = path.join(process.cwd(), ".hot-updater");
-	await fs.mkdir(downloadRoot, { recursive: true });
-	const workDir = await fs.mkdtemp(path.join(downloadRoot, HOT_UPDATER_DOWNLOAD_DIR_PREFIX));
-	const filename = path.basename(new URL(storageUri).pathname) || randomUUID();
-	const filePath = path.join(workDir, filename);
-	try {
-		await storagePlugin.profiles.node.downloadFile(storageUri, filePath);
-		return new Uint8Array(await fs.readFile(filePath));
-	} finally {
-		await fs.rm(workDir, {
-			force: true,
-			recursive: true
-		});
+	if (!storagePlugin || storagePlugin.protocol !== protocol) {
+		if (protocol === "http" || protocol === "https") return downloadFromUrl(storageUri);
+		if (!storagePlugin) throw new Error("Storage plugin is not configured");
+		throw new Error(`No storage plugin for protocol: ${protocol}`);
 	}
+	const { response } = await storagePlugin.get({ storageUri });
+	if (response === null) throw new Error(`Storage object not found: ${storageUri}`);
+	return new Uint8Array(await response.arrayBuffer());
 }
 async function fetchManifest(bundle, storagePlugin) {
 	const manifestStorageUri = getManifestStorageUri(bundle);
@@ -76,12 +64,16 @@ async function fetchAssetBytes(bundle, assetPath, manifest, storagePlugin) {
 		const compressedAssetStorageUri = resolveManifestAssetStorageUri({
 			assetBaseStorageUri,
 			assetPath: downloadPath,
+			downloadFileHash: asset.downloadFileHash,
 			fileHash: asset.fileHash
 		});
 		let compressedBytes = null;
 		try {
 			compressedBytes = await downloadStorageBytes(compressedAssetStorageUri, storagePlugin);
-		} catch {}
+		} catch (error) {
+			if (!(error instanceof Error)) throw error;
+			compressedBytes = null;
+		}
 		if (compressedBytes) return new Uint8Array(await decompressBrotli(compressedBytes));
 	}
 	return downloadStorageBytes(resolveManifestAssetStorageUri({
@@ -90,23 +82,16 @@ async function fetchAssetBytes(bundle, assetPath, manifest, storagePlugin) {
 		fileHash: asset.fileHash
 	}), storagePlugin);
 }
-async function getFileHash(filePath) {
-	const file = await fs.readFile(filePath);
-	return crypto.createHash("sha256").update(file).digest("hex");
-}
 function buildNextPatchState({ currentBundle, nextPatch, makePrimary }) {
 	const existingPatches = getBundlePatches(currentBundle).filter((patch) => patch.baseBundleId !== nextPatch.baseBundleId);
-	const orderedPatches = makePrimary ? [nextPatch, ...existingPatches] : [...existingPatches, nextPatch];
-	return {
-		patches: orderedPatches,
-		primaryPatch: orderedPatches[0] ?? nextPatch
-	};
+	return makePrimary ? [nextPatch, ...existingPatches] : [...existingPatches, nextPatch];
 }
 async function createBundleDiff({ baseBundleId, bundleId }, deps, options = {}) {
+	const database = createDatabaseClient(deps.databasePlugin);
 	if (!deps.storagePlugin) throw new Error("Storage plugin is not configured");
 	if (baseBundleId === bundleId) throw new Error("Base bundle must be different from the target bundle");
-	const baseBundle = await deps.databasePlugin.getBundleById(baseBundleId);
-	const targetBundle = await deps.databasePlugin.getBundleById(bundleId);
+	const baseBundle = await database.getBundleById(baseBundleId);
+	const targetBundle = await database.getBundleById(bundleId);
 	if (!baseBundle || !targetBundle) throw new Error("Bundle not found");
 	if (baseBundle.platform !== targetBundle.platform) throw new Error("Base bundle platform must match the target bundle");
 	if (baseBundle.id.localeCompare(targetBundle.id) >= 0) throw new Error("Base bundle must be older than the target bundle");
@@ -120,43 +105,37 @@ async function createBundleDiff({ baseBundleId, bundleId }, deps, options = {})
 	if (baseAssetHash === targetAssetHash) throw new Error("Hermes bundle is unchanged; no diff patch is required");
 	const [baseBytes, targetBytes] = await Promise.all([fetchAssetBytes(baseBundle, baseAssetPath, baseManifest, deps.storagePlugin), fetchAssetBytes(targetBundle, targetAssetPath, targetManifest, deps.storagePlugin)]);
 	const patchBytes = await hdiff(baseBytes, targetBytes);
-	const workDir = await fs.mkdtemp(path.join(os.tmpdir(), "hot-updater-console-bsdiff-"));
+	const patchFileHash = crypto.createHash("sha256").update(patchBytes).digest("hex");
 	const patchFilename = `${path.posix.basename(targetAssetPath)}.bsdiff`;
-	const patchPath = path.join(workDir, patchFilename);
 	const previousPatch = getBundlePatch(targetBundle, baseBundle.id);
-	try {
-		await fs.writeFile(patchPath, patchBytes);
-		const uploadKey = createBundleStorageKey(targetBundle.id, "patches", baseBundle.id, getRelativeStorageDir(targetAssetPath));
-		const patchUpload = await deps.storagePlugin.profiles.node.upload(uploadKey, patchPath);
-		const patchFileHash = await getFileHash(patchPath);
-		const nextState = buildNextPatchState({
-			currentBundle: targetBundle,
-			nextPatch: {
-				baseBundleId: baseBundle.id,
-				baseFileHash: baseAssetHash,
-				patchFileHash,
-				patchStorageUri: patchUpload.storageUri
-			},
-			makePrimary: options.makePrimary ?? true
-		});
-		await deps.databasePlugin.updateBundle(targetBundle.id, {
-			patches: nextState.patches,
-			patchBaseBundleId: nextState.primaryPatch.baseBundleId,
-			patchBaseFileHash: nextState.primaryPatch.baseFileHash,
-			patchFileHash: nextState.primaryPatch.patchFileHash,
-			patchStorageUri: nextState.primaryPatch.patchStorageUri
-		});
-		await deps.databasePlugin.commitBundle();
-		if (previousPatch?.patchStorageUri && previousPatch.patchStorageUri !== patchUpload.storageUri) await deps.storagePlugin.profiles.node.delete(previousPatch.patchStorageUri).catch(() => {});
-		const updatedBundle = await deps.databasePlugin.getBundleById(targetBundle.id);
-		if (!updatedBundle) throw new Error("Updated bundle not found");
-		return updatedBundle;
-	} finally {
-		await fs.rm(workDir, {
-			force: true,
-			recursive: true
-		});
-	}
+	const uploadKey = createBundleStorageKey(targetBundle.id, "patches", baseBundle.id, patchFileHash, getRelativeStorageDir(targetAssetPath), patchFilename);
+	const patchUpload = await deps.storagePlugin.put({
+		key: uploadKey,
+		body: new ReadableStream({ start(controller) {
+			controller.enqueue(patchBytes);
+			controller.close();
+		} }),
+		contentLength: patchBytes.byteLength,
+		contentType: "application/octet-stream"
+	});
+	const patches = buildNextPatchState({
+		currentBundle: targetBundle,
+		nextPatch: {
+			baseBundleId: baseBundle.id,
+			baseFileHash: baseAssetHash,
+			byteSize: patchBytes.byteLength,
+			patchFileHash,
+			patchStorageUri: patchUpload.storageUri
+		},
+		makePrimary: options.makePrimary ?? true
+	});
+	const updatedBundle = {
+		...targetBundle,
+		patches
+	};
+	await database.updateBundleById(targetBundle.id, updatedBundle);
+	if (previousPatch?.patchStorageUri && previousPatch.patchStorageUri !== patchUpload.storageUri) await deps.storagePlugin.delete({ storageUri: previousPatch.patchStorageUri }).catch(() => {});
+	return updatedBundle;
 }
 //#endregion
 export { createBundleDiff };

package/dist/db/databasePluginCore.cjs

@@ -0,0 +1,138 @@
+require("../_virtual/_rolldown/runtime.cjs");
+const require_releaseCatalog = require("./releaseCatalog.cjs");
+let _hot_updater_plugin_core = require("@hot-updater/plugin-core");
+let _hot_updater_core = require("@hot-updater/core");
+//#region src/db/databasePluginCore.ts
+function createDatabasePluginCore(database, resolveFileUrl, options) {
+	const client = (0, _hot_updater_plugin_core.createDatabaseClient)(database);
+	const beforeOperation = options?.beforeOperation;
+	const getReleaseCatalog = require_releaseCatalog.createReleaseCatalogReader(database);
+	const getArtifact = require_releaseCatalog.createArtifactResolver({
+		database,
+		readStorageText: options?.readStorageText,
+		resolveFileUrl
+	});
+	return {
+		api: {
+			async getBundleById(id) {
+				await beforeOperation?.();
+				return client.getBundleById(id);
+			},
+			async getReleaseCatalog(input) {
+				await beforeOperation?.();
+				return getReleaseCatalog(input);
+			},
+			async getArtifactInfo(targetBundleId, currentBundleId) {
+				await beforeOperation?.();
+				return getArtifact(targetBundleId, currentBundleId);
+			},
+			async getReleaseById(id) {
+				await beforeOperation?.();
+				return database.models.releases.findById(id);
+			},
+			async getReleasesByScope(input) {
+				await beforeOperation?.();
+				return database.models.releases.findManyByScope({
+					...input,
+					consistency: "strong"
+				});
+			},
+			async getReleases(input) {
+				await beforeOperation?.();
+				return database.models.releases.findMany(input);
+			},
+			async getReleaseCatalogByScopeKey(scopeKey) {
+				await beforeOperation?.();
+				return database.models.releaseCatalogs.findByScopeKey(scopeKey);
+			},
+			async getReleaseCatalogs(input) {
+				await beforeOperation?.();
+				return database.models.releaseCatalogs.findMany(input);
+			},
+			async updateReleasePolicy(input) {
+				await beforeOperation?.();
+				return (0, _hot_updater_plugin_core.updateReleasePolicy)({
+					database,
+					...input
+				});
+			},
+			async preflightReleasePolicy(input) {
+				await beforeOperation?.();
+				return (0, _hot_updater_plugin_core.preflightReleasePolicy)({
+					database,
+					...input
+				});
+			},
+			async deleteRelease(input) {
+				await beforeOperation?.();
+				return (0, _hot_updater_plugin_core.deleteRelease)({
+					database,
+					...input
+				});
+			},
+			async rebuildReleaseCatalog(scopeKey) {
+				await beforeOperation?.();
+				const catalog = await database.models.releaseCatalogs.findByScopeKey(scopeKey);
+				if (catalog === null) throw new Error(`Release catalog "${scopeKey}" was not found.`);
+				return (0, _hot_updater_plugin_core.rebuildReleaseCatalog)({
+					database,
+					scope: {
+						channelId: catalog.channel_id,
+						channelName: (0, _hot_updater_core.decodeChannelKey)(catalog.channel_key),
+						fingerprintHash: catalog.fingerprint_hash,
+						platform: catalog.platform,
+						scopeKey: catalog.scope_key,
+						strategy: catalog.strategy
+					}
+				});
+			},
+			async commitDatabase(input) {
+				await beforeOperation?.();
+				return database.commit(input);
+			},
+			async getChannels() {
+				await beforeOperation?.();
+				return client.getChannels();
+			},
+			async insertChannel(input) {
+				await beforeOperation?.();
+				return database.models.channels.insert(input);
+			},
+			async deleteChannel(input) {
+				await beforeOperation?.();
+				return database.models.channels.delete(input);
+			},
+			async getBundles(options) {
+				await beforeOperation?.();
+				return client.getBundles(options);
+			},
+			async insertBundle(bundle) {
+				await beforeOperation?.();
+				await client.insertBundle(bundle);
+			},
+			async insertBundles(bundles) {
+				await beforeOperation?.();
+				await client.mutate(async (transaction) => {
+					for (const bundle of bundles) await transaction.insertBundle(bundle);
+				});
+			},
+			async updateBundleById(bundleId, update) {
+				await beforeOperation?.();
+				await client.updateBundleById(bundleId, update);
+			},
+			async deleteBundleById(bundleId) {
+				await beforeOperation?.();
+				await client.deleteBundleById(bundleId);
+			}
+		},
+		adapterName: database.name,
+		createMigrator: () => {
+			throw new Error("createMigrator is only available for Kysely/MongoDB database plugins.");
+		},
+		generateSchema: () => {
+			throw new Error("generateSchema is only available for Drizzle/Prisma database plugins.");
+		}
+	};
+}
+//#endregion
+exports.createDatabasePluginCore = createDatabasePluginCore;

package/dist/db/databasePluginCore.mjs

@@ -0,0 +1,137 @@
+import { createArtifactResolver, createReleaseCatalogReader } from "./releaseCatalog.mjs";
+import { createDatabaseClient, deleteRelease, preflightReleasePolicy, rebuildReleaseCatalog, updateReleasePolicy } from "@hot-updater/plugin-core";
+import { decodeChannelKey } from "@hot-updater/core";
+//#region src/db/databasePluginCore.ts
+function createDatabasePluginCore(database, resolveFileUrl, options) {
+	const client = createDatabaseClient(database);
+	const beforeOperation = options?.beforeOperation;
+	const getReleaseCatalog = createReleaseCatalogReader(database);
+	const getArtifact = createArtifactResolver({
+		database,
+		readStorageText: options?.readStorageText,
+		resolveFileUrl
+	});
+	return {
+		api: {
+			async getBundleById(id) {
+				await beforeOperation?.();
+				return client.getBundleById(id);
+			},
+			async getReleaseCatalog(input) {
+				await beforeOperation?.();
+				return getReleaseCatalog(input);
+			},
+			async getArtifactInfo(targetBundleId, currentBundleId) {
+				await beforeOperation?.();
+				return getArtifact(targetBundleId, currentBundleId);
+			},
+			async getReleaseById(id) {
+				await beforeOperation?.();
+				return database.models.releases.findById(id);
+			},
+			async getReleasesByScope(input) {
+				await beforeOperation?.();
+				return database.models.releases.findManyByScope({
+					...input,
+					consistency: "strong"
+				});
+			},
+			async getReleases(input) {
+				await beforeOperation?.();
+				return database.models.releases.findMany(input);
+			},
+			async getReleaseCatalogByScopeKey(scopeKey) {
+				await beforeOperation?.();
+				return database.models.releaseCatalogs.findByScopeKey(scopeKey);
+			},
+			async getReleaseCatalogs(input) {
+				await beforeOperation?.();
+				return database.models.releaseCatalogs.findMany(input);
+			},
+			async updateReleasePolicy(input) {
+				await beforeOperation?.();
+				return updateReleasePolicy({
+					database,
+					...input
+				});
+			},
+			async preflightReleasePolicy(input) {
+				await beforeOperation?.();
+				return preflightReleasePolicy({
+					database,
+					...input
+				});
+			},
+			async deleteRelease(input) {
+				await beforeOperation?.();
+				return deleteRelease({
+					database,
+					...input
+				});
+			},
+			async rebuildReleaseCatalog(scopeKey) {
+				await beforeOperation?.();
+				const catalog = await database.models.releaseCatalogs.findByScopeKey(scopeKey);
+				if (catalog === null) throw new Error(`Release catalog "${scopeKey}" was not found.`);
+				return rebuildReleaseCatalog({
+					database,
+					scope: {
+						channelId: catalog.channel_id,
+						channelName: decodeChannelKey(catalog.channel_key),
+						fingerprintHash: catalog.fingerprint_hash,
+						platform: catalog.platform,
+						scopeKey: catalog.scope_key,
+						strategy: catalog.strategy
+					}
+				});
+			},
+			async commitDatabase(input) {
+				await beforeOperation?.();
+				return database.commit(input);
+			},
+			async getChannels() {
+				await beforeOperation?.();
+				return client.getChannels();
+			},
+			async insertChannel(input) {
+				await beforeOperation?.();
+				return database.models.channels.insert(input);
+			},
+			async deleteChannel(input) {
+				await beforeOperation?.();
+				return database.models.channels.delete(input);
+			},
+			async getBundles(options) {
+				await beforeOperation?.();
+				return client.getBundles(options);
+			},
+			async insertBundle(bundle) {
+				await beforeOperation?.();
+				await client.insertBundle(bundle);
+			},
+			async insertBundles(bundles) {
+				await beforeOperation?.();
+				await client.mutate(async (transaction) => {
+					for (const bundle of bundles) await transaction.insertBundle(bundle);
+				});
+			},
+			async updateBundleById(bundleId, update) {
+				await beforeOperation?.();
+				await client.updateBundleById(bundleId, update);
+			},
+			async deleteBundleById(bundleId) {
+				await beforeOperation?.();
+				await client.deleteBundleById(bundleId);
+			}
+		},
+		adapterName: database.name,
+		createMigrator: () => {
+			throw new Error("createMigrator is only available for Kysely/MongoDB database plugins.");
+		},
+		generateSchema: () => {
+			throw new Error("generateSchema is only available for Drizzle/Prisma database plugins.");
+		}
+	};
+}
+//#endregion
+export { createDatabasePluginCore };

package/dist/db/fixedMigrator.cjs

@@ -1,131 +1,75 @@
+require("../_virtual/_rolldown/runtime.cjs");
 const require_types = require("../schema/types.cjs");
-const require_registry = require("./schema/registry.cjs");
+const require_fixedMigratorShared = require("./fixedMigratorShared.cjs");
 const require_sql = require("./schema/sql.cjs");
-const require_mongodb = require("./schema/mongodb.cjs");
-const require_sqlMigrations = require("./schema/sqlMigrations.cjs");
 const require_sqlOperations = require("./schema/sqlOperations.cjs");
+const require_sqlMigrationExecution = require("./sqlMigrationExecution.cjs");
+require("./fixedMigratorMongo.cjs");
+let kysely = require("kysely");
 //#region src/db/fixedMigrator.ts
-const getEmptyResult = () => ({
-	operations: [],
-	execute: async () => {},
-	getSQL: () => ""
-});
-const assertSupportedMigrationMode = (options) => {
-	if (options.mode === "from-database") throw new Error("Hot Updater migrations support only mode: 'from-schema'.");
-};
 const isMissingSettingsTableError = (error) => {
 	if (!(error instanceof Error)) return false;
 	const message = error.message.toLowerCase();
 	return message.includes("private_hot_updater_settings") && (message.includes("does not exist") || message.includes("no such table") || message.includes("doesn't exist") || message.includes("not found"));
 };
-const isMongoNamespaceExistsError = (error) => {
-	if (!(error instanceof Error)) return false;
-	const mongoError = error;
-	return mongoError.code === 48 || mongoError.codeName === "NamespaceExists";
-};
-const ignoreExistingCollection = (error) => {
-	if (isMongoNamespaceExistsError(error)) return;
-	throw error;
-};
-const toCustomOperations = (statements, settingsOperation) => [...statements.map((statement) => ({
-	type: "custom",
-	sql: statement
-})), ...settingsOperation ? [settingsOperation] : []];
-const assertSupportedSchemaVersion = (currentVersion) => {
-	if (currentVersion !== void 0 && currentVersion !== "0.21.0" && currentVersion !== "0.29.0") throw new Error(`Unsupported Hot Updater schema version: ${currentVersion}`);
-};
 const createKyselyMigrator = ({ db, provider, relationMode = "foreign-keys" }) => {
-	const getVersion = async () => {
+	const getSetting = async (key) => {
 		try {
-			const row = await db.selectFrom(require_types.HOT_UPDATER_SETTINGS_TABLE).select("value").where("key", "=", "version").executeTakeFirst();
-			return typeof row?.value === "string" ? row.value : void 0;
+			const row = (await kysely.sql`select ${kysely.sql.ref("value")} from ${kysely.sql.table(require_types.HOT_UPDATER_SETTINGS_TABLE)} where ${kysely.sql.ref("key")} = ${key} limit 1`.execute(db)).rows[0];
+			if (!row) return void 0;
+			if (typeof row.value !== "string") throw new Error(`Invalid Hot Updater schema setting: ${key}`);
+			return row.value;
 		} catch (error) {
 			if (!isMissingSettingsTableError(error)) throw error;
 			return;
 		}
 	};
+	const getCoreVersion = () => getSetting(require_types.HOT_UPDATER_CORE_SCHEMA_KEY);
+	const getSchemaVersions = async () => {
+		return {
+			coreVersion: await getCoreVersion(),
+			legacyCoreVersion: require_fixedMigratorShared.inferLegacyCoreSchemaVersion(await getSetting("version"))
+		};
+	};
+	const getVersion = async () => {
+		const { coreVersion, legacyCoreVersion } = await getSchemaVersions();
+		return coreVersion ?? legacyCoreVersion;
+	};
 	const makeResult = async (options = {}) => {
-		assertSupportedMigrationMode(options);
-		const currentVersion = await getVersion();
-		if (currentVersion === "0.31.0") return getEmptyResult();
-		assertSupportedSchemaVersion(currentVersion);
+		require_fixedMigratorShared.assertSupportedMigrationMode(options);
+		const { coreVersion, legacyCoreVersion } = await getSchemaVersions();
+		if (require_fixedMigratorShared.isCurrentSchemaVersion(coreVersion)) return require_fixedMigratorShared.getEmptyMigrationResult();
+		require_fixedMigratorShared.assertCurrentOrEmptySchemaVersion(coreVersion ?? legacyCoreVersion);
 		const settingsStatement = require_sqlOperations.getSettingsInsertSql(provider);
 		const settingsOperation = options.updateSettings === false ? void 0 : {
 			type: "custom",
 			sql: settingsStatement
 		};
-		const executableSettingsStatements = options.updateSettings === false ? [] : [settingsStatement];
-		const statements = currentVersion === void 0 ? [...require_sql.createTableSql(provider, relationMode), settingsStatement] : [
-			...currentVersion === "0.21.0" ? require_sqlMigrations.createV029AlterSql(provider) : [],
-			...currentVersion === "0.21.0" || currentVersion === "0.29.0" ? require_sqlMigrations.createV031AlterSql(provider, relationMode) : [],
-			...executableSettingsStatements
-		];
+		const statements = [...require_sql.createTableSql(provider, relationMode), settingsStatement];
 		return {
-			operations: currentVersion === void 0 ? require_sqlOperations.createSqlCreateOperations(provider, relationMode, settingsOperation) : toCustomOperations([...currentVersion === "0.21.0" ? require_sqlMigrations.createV029AlterSql(provider) : [], ...currentVersion === "0.21.0" || currentVersion === "0.29.0" ? require_sqlMigrations.createV031AlterSql(provider, relationMode) : []], settingsOperation),
+			operations: require_sqlOperations.createSqlCreateOperations(provider, relationMode, settingsOperation),
 			getSQL: () => statements.map((statement) => `${statement};`).join("\n\n"),
-			execute: async () => {
-				const { sql } = await import("kysely");
-				for (const statement of statements) await sql.raw(statement).execute(db);
-			}
+			execute: () => require_sqlMigrationExecution.executeMigrationStatements({
+				db,
+				provider,
+				statements
+			})
 		};
 	};
 	return {
 		getVersion,
 		getNameVariants: async () => void 0,
-		next: async () => await getVersion() === "0.31.0" ? void 0 : { version: require_types.HOT_UPDATER_SCHEMA_VERSION },
-		previous: async () => void 0,
-		up: makeResult,
-		down: async () => {
-			throw new Error("No previous schema to migrate to.");
+		next: async () => {
+			const { coreVersion } = await getSchemaVersions();
+			return require_fixedMigratorShared.isCurrentSchemaVersion(coreVersion) ? void 0 : { version: require_types.HOT_UPDATER_SCHEMA_VERSION };
 		},
-		migrateTo: async (version, options) => {
-			if (version !== "0.31.0") throw new Error(`Invalid version ${version}`);
-			return makeResult(options);
-		},
-		migrateToLatest: makeResult
-	};
-};
-const createMongoMigrator = (client) => {
-	const settings = client.db().collection(require_types.HOT_UPDATER_SETTINGS_TABLE);
-	const getVersion = async () => {
-		const row = await settings.findOne({ key: "version" });
-		return typeof row?.value === "string" ? row.value : void 0;
-	};
-	const makeResult = async (options = {}) => {
-		assertSupportedMigrationMode(options);
-		if (await getVersion() === "0.31.0") return getEmptyResult();
-		return {
-			operations: require_mongodb.createMongoMigrationOperations(options.updateSettings === false ? void 0 : {
-				type: "custom",
-				key: "version",
-				value: require_types.HOT_UPDATER_SCHEMA_VERSION
-			}),
-			execute: async () => {
-				const db = client.db();
-				for (const table of require_registry.hotUpdaterSchema.tables) {
-					if (table.internal) continue;
-					await db.createCollection(table.ormName).catch(ignoreExistingCollection);
-				}
-				await db.collection("bundles").createIndex({ id: 1 }, { name: "bundles_id_idx" });
-				for (const table of require_registry.hotUpdaterSchema.tables) {
-					if (table.internal) continue;
-					for (const index of (table.indexes ?? []).filter((item) => require_registry.schemaIndexAppliesToProvider(item, "mongodb"))) await db.collection(table.ormName).createIndex(Object.fromEntries(index.columns.map((column) => [column, 1])), { name: index.name });
-				}
-				if (options.updateSettings !== false) await settings.updateOne({ key: "version" }, { $set: { value: require_types.HOT_UPDATER_SCHEMA_VERSION } }, { upsert: true });
-			}
-		};
-	};
-	return {
-		getVersion,
-		getNameVariants: async () => void 0,
-		next: async () => await getVersion() === "0.31.0" ? void 0 : { version: require_types.HOT_UPDATER_SCHEMA_VERSION },
 		previous: async () => void 0,
 		up: makeResult,
 		down: async () => {
 			throw new Error("No previous schema to migrate to.");
 		},
 		migrateTo: async (version, options) => {
-			if (version !== "0.31.0") throw new Error(`Invalid version ${version}`);
+			if (version !== "1.0.0") throw new Error(`Invalid version ${version}`);
 			return makeResult(options);
 		},
 		migrateToLatest: makeResult
@@ -133,4 +77,3 @@ const createMongoMigrator = (client) => {
 };
 //#endregion
 exports.createKyselyMigrator = createKyselyMigrator;
-exports.createMongoMigrator = createMongoMigrator;