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

package/dist/db/fixedMigrator.mjs

@@ -1,135 +1,78 @@
-import { HOT_UPDATER_SCHEMA_VERSION, HOT_UPDATER_SETTINGS_TABLE } from "../schema/types.mjs";
-import { hotUpdaterSchema, schemaIndexAppliesToProvider } from "./schema/registry.mjs";
+import { HOT_UPDATER_CORE_SCHEMA_KEY, HOT_UPDATER_SCHEMA_VERSION, HOT_UPDATER_SETTINGS_TABLE } from "../schema/types.mjs";
+import { assertCurrentOrEmptySchemaVersion, assertSupportedMigrationMode, getEmptyMigrationResult, inferLegacyCoreSchemaVersion, isCurrentSchemaVersion } from "./fixedMigratorShared.mjs";
 import { createTableSql } from "./schema/sql.mjs";
-import { createMongoMigrationOperations } from "./schema/mongodb.mjs";
-import { createV029AlterSql, createV031AlterSql } from "./schema/sqlMigrations.mjs";
 import { createSqlCreateOperations, getSettingsInsertSql } from "./schema/sqlOperations.mjs";
+import { executeMigrationStatements } from "./sqlMigrationExecution.mjs";
+import "./fixedMigratorMongo.mjs";
+import { sql } from "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(HOT_UPDATER_SETTINGS_TABLE).select("value").where("key", "=", "version").executeTakeFirst();
-			return typeof row?.value === "string" ? row.value : void 0;
+			const row = (await sql`select ${sql.ref("value")} from ${sql.table(HOT_UPDATER_SETTINGS_TABLE)} where ${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(HOT_UPDATER_CORE_SCHEMA_KEY);
+	const getSchemaVersions = async () => {
+		return {
+			coreVersion: await getCoreVersion(),
+			legacyCoreVersion: 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);
+		const { coreVersion, legacyCoreVersion } = await getSchemaVersions();
+		if (isCurrentSchemaVersion(coreVersion)) return getEmptyMigrationResult();
+		assertCurrentOrEmptySchemaVersion(coreVersion ?? legacyCoreVersion);
 		const settingsStatement = getSettingsInsertSql(provider);
 		const settingsOperation = options.updateSettings === false ? void 0 : {
 			type: "custom",
 			sql: settingsStatement
 		};
-		const executableSettingsStatements = options.updateSettings === false ? [] : [settingsStatement];
-		const statements = currentVersion === void 0 ? [...createTableSql(provider, relationMode), settingsStatement] : [
-			...currentVersion === "0.21.0" ? createV029AlterSql(provider) : [],
-			...currentVersion === "0.21.0" || currentVersion === "0.29.0" ? createV031AlterSql(provider, relationMode) : [],
-			...executableSettingsStatements
-		];
+		const statements = [...createTableSql(provider, relationMode), settingsStatement];
 		return {
-			operations: currentVersion === void 0 ? createSqlCreateOperations(provider, relationMode, settingsOperation) : toCustomOperations([...currentVersion === "0.21.0" ? createV029AlterSql(provider) : [], ...currentVersion === "0.21.0" || currentVersion === "0.29.0" ? createV031AlterSql(provider, relationMode) : []], settingsOperation),
+			operations: 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: () => executeMigrationStatements({
+				db,
+				provider,
+				statements
+			})
 		};
 	};
 	return {
 		getVersion,
 		getNameVariants: async () => void 0,
-		next: async () => await getVersion() === "0.31.0" ? void 0 : { version: 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 isCurrentSchemaVersion(coreVersion) ? void 0 : { version: 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(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: createMongoMigrationOperations(options.updateSettings === false ? void 0 : {
-				type: "custom",
-				key: "version",
-				value: HOT_UPDATER_SCHEMA_VERSION
-			}),
-			execute: async () => {
-				const db = client.db();
-				for (const table of 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 hotUpdaterSchema.tables) {
-					if (table.internal) continue;
-					for (const index of (table.indexes ?? []).filter((item) => 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: HOT_UPDATER_SCHEMA_VERSION } }, { upsert: true });
-			}
-		};
-	};
-	return {
-		getVersion,
-		getNameVariants: async () => void 0,
-		next: async () => await getVersion() === "0.31.0" ? void 0 : { version: 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
 	};
 };
 //#endregion
-export { createKyselyMigrator, createMongoMigrator };
+export { createKyselyMigrator };

package/dist/db/fixedMigratorMongo.cjs

@@ -0,0 +1,319 @@
+const require_types = require("../schema/types.cjs");
+const require_fixedMigratorShared = require("./fixedMigratorShared.cjs");
+const require_registry = require("./schema/registry.cjs");
+const require_mongoMigrationExecution = require("./mongoMigrationExecution.cjs");
+const require_mongodb = require("./schema/mongodb.cjs");
+//#region src/db/fixedMigratorMongo.ts
+const isMongoNamespaceExistsError = (error) => {
+	if (!(error instanceof Error)) return false;
+	const mongoError = error;
+	return mongoError.code === 48 || mongoError.codeName === "NamespaceExists";
+};
+const isMongoNamespaceNotFoundError = (error) => {
+	if (!(error instanceof Error)) return false;
+	const mongoError = error;
+	return mongoError.code === 26 || mongoError.codeName === "NamespaceNotFound";
+};
+const ignoreExistingCollection = (error) => {
+	if (isMongoNamespaceExistsError(error)) return;
+	throw error;
+};
+const mongoNullableString = { bsonType: ["string", "null"] };
+const mongoByteSize = {
+	bsonType: [
+		"double",
+		"int",
+		"long"
+	],
+	maximum: Number.MAX_SAFE_INTEGER,
+	minimum: 0
+};
+const mongoBundleValidator = { $and: [{ $jsonSchema: {
+	bsonType: "object",
+	properties: {
+		archive_byte_size: mongoByteSize,
+		asset_base_storage_uri: mongoNullableString,
+		file_hash: { bsonType: "string" },
+		git_commit_hash: mongoNullableString,
+		id: { bsonType: "string" },
+		manifest_file_hash: mongoNullableString,
+		manifest_storage_uri: mongoNullableString,
+		metadata: { bsonType: "object" },
+		platform: { enum: ["ios", "android"] },
+		storage_uri: { bsonType: "string" }
+	},
+	required: [
+		"id",
+		"platform",
+		"file_hash",
+		"git_commit_hash",
+		"storage_uri",
+		"archive_byte_size",
+		"metadata",
+		"manifest_storage_uri",
+		"manifest_file_hash",
+		"asset_base_storage_uri"
+	]
+} }, { $expr: { $eq: [{ $trunc: "$archive_byte_size" }, "$archive_byte_size"] } }] };
+const mongoPatchValidator = { $and: [{ $jsonSchema: {
+	bsonType: "object",
+	properties: {
+		base_bundle_id: { bsonType: "string" },
+		base_file_hash: { bsonType: "string" },
+		bundle_id: { bsonType: "string" },
+		id: { bsonType: "string" },
+		order_index: mongoByteSize,
+		byte_size: mongoByteSize,
+		patch_file_hash: { bsonType: "string" },
+		patch_storage_uri: { bsonType: "string" }
+	},
+	required: [
+		"id",
+		"bundle_id",
+		"base_bundle_id",
+		"base_file_hash",
+		"patch_file_hash",
+		"patch_storage_uri",
+		"byte_size",
+		"order_index"
+	]
+} }, { $expr: { $and: [{ $eq: [{ $trunc: "$order_index" }, "$order_index"] }, { $eq: [{ $trunc: "$byte_size" }, "$byte_size"] }] } }] };
+const mongoReleaseValidator = { $jsonSchema: {
+	bsonType: "object",
+	properties: {
+		bundle_id: mongoNullableString,
+		channel_id: { bsonType: "string" },
+		created_at_ms: { bsonType: [
+			"double",
+			"int",
+			"long"
+		] },
+		enabled: { bsonType: "bool" },
+		fingerprint_hash: mongoNullableString,
+		id: { bsonType: "string" },
+		kind: { enum: ["BUNDLE", "EMBEDDED"] },
+		message: mongoNullableString,
+		operation: { enum: [
+			"DEPLOY",
+			"PROMOTE",
+			"ROLLBACK"
+		] },
+		platform: { enum: ["ios", "android"] },
+		revision: { bsonType: ["int", "long"] },
+		rollout_cohort_count: { bsonType: ["int", "long"] },
+		scope_key: { bsonType: "string" },
+		should_force_update: { bsonType: "bool" },
+		source_release_id: mongoNullableString,
+		strategy: { enum: ["APP_VERSION", "FINGERPRINT"] },
+		target_app_version: mongoNullableString,
+		target_cohorts: {
+			bsonType: "array",
+			items: { bsonType: "string" }
+		},
+		updated_at_ms: { bsonType: [
+			"double",
+			"int",
+			"long"
+		] }
+	},
+	required: [
+		"id",
+		"revision",
+		"scope_key",
+		"channel_id",
+		"platform",
+		"kind",
+		"bundle_id",
+		"strategy",
+		"target_app_version",
+		"fingerprint_hash",
+		"enabled",
+		"should_force_update",
+		"message",
+		"rollout_cohort_count",
+		"target_cohorts",
+		"operation",
+		"source_release_id",
+		"created_at_ms",
+		"updated_at_ms"
+	]
+} };
+const mongoReleaseCatalogValidator = { $jsonSchema: {
+	bsonType: "object",
+	properties: {
+		catalog_id: { bsonType: "string" },
+		byte_size: { bsonType: ["int", "long"] },
+		catalog_hash: { bsonType: "string" },
+		channel_id: { bsonType: "string" },
+		channel_key: { bsonType: "string" },
+		fingerprint_hash: mongoNullableString,
+		generation: { bsonType: [
+			"double",
+			"int",
+			"long"
+		] },
+		is_tombstone: { bsonType: "bool" },
+		payload: { bsonType: "string" },
+		platform: { enum: ["ios", "android"] },
+		scope_key: { bsonType: "string" },
+		strategy: { enum: ["APP_VERSION", "FINGERPRINT"] },
+		updated_at_ms: { bsonType: [
+			"double",
+			"int",
+			"long"
+		] }
+	},
+	required: [
+		"scope_key",
+		"catalog_id",
+		"strategy",
+		"channel_id",
+		"channel_key",
+		"platform",
+		"fingerprint_hash",
+		"generation",
+		"payload",
+		"catalog_hash",
+		"byte_size",
+		"is_tombstone",
+		"updated_at_ms"
+	]
+} };
+const createSettingsKeyIndexOperation = () => ({
+	description: `Ensure unique MongoDB index: ${require_types.HOT_UPDATER_SETTINGS_TABLE}(key)`,
+	type: "custom"
+});
+const createMongoMigrator = (client) => {
+	const settings = client.db().collection(require_types.HOT_UPDATER_SETTINGS_TABLE);
+	const getSetting = async (key) => {
+		const [row, duplicate] = await settings.find({ key }).limit(2).toArray();
+		if (!row) return void 0;
+		if (duplicate) throw new Error(`Duplicate Hot Updater schema setting: ${key}`);
+		if (typeof row.value !== "string") throw new Error(`Invalid Hot Updater schema setting: ${key}`);
+		return row.value;
+	};
+	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 getSettingsKeyIndexState = async () => {
+		const index = (await settings.listIndexes().toArray().catch((error) => {
+			if (isMongoNamespaceNotFoundError(error)) return [];
+			throw error;
+		})).find(({ key }) => {
+			const fields = Object.entries(key);
+			return fields.length === 1 && fields[0]?.[0] === "key" && fields[0][1] === 1;
+		});
+		if (!index) return "missing";
+		return index.unique === true && index.sparse !== true && index.partialFilterExpression === void 0 ? "unique" : "non-unique";
+	};
+	const rejectNonUniqueSettingsKeyIndex = () => {
+		throw new Error("Hot Updater settings key index must enforce uniqueness for every key.");
+	};
+	const ensureSettingsKeyIndex = async () => {
+		const state = await getSettingsKeyIndexState();
+		if (state === "unique") return;
+		if (state === "non-unique") rejectNonUniqueSettingsKeyIndex();
+		await settings.createIndex({ key: 1 }, { unique: true });
+	};
+	const makeResult = async (options = {}) => {
+		require_fixedMigratorShared.assertSupportedMigrationMode(options);
+		const { coreVersion, legacyCoreVersion } = await getSchemaVersions();
+		const settingsKeyIndexState = await getSettingsKeyIndexState();
+		if (settingsKeyIndexState === "non-unique") rejectNonUniqueSettingsKeyIndex();
+		if (require_fixedMigratorShared.isCurrentSchemaVersion(coreVersion)) {
+			if (settingsKeyIndexState === "unique") return require_fixedMigratorShared.getEmptyMigrationResult();
+			return {
+				...require_fixedMigratorShared.getEmptyMigrationResult(),
+				execute: ensureSettingsKeyIndex,
+				operations: [createSettingsKeyIndexOperation()]
+			};
+		}
+		require_fixedMigratorShared.assertCurrentOrEmptySchemaVersion(coreVersion ?? legacyCoreVersion);
+		const settingsOperation = options.updateSettings === false ? void 0 : {
+			type: "custom",
+			key: require_types.HOT_UPDATER_CORE_SCHEMA_KEY,
+			value: require_types.HOT_UPDATER_SCHEMA_VERSION
+		};
+		return {
+			operations: [createSettingsKeyIndexOperation(), ...require_mongodb.createMongoMigrationOperations(settingsOperation)],
+			execute: async () => {
+				const db = client.db();
+				await require_mongoMigrationExecution.executeMongoMigration({
+					updateSettings: options.updateSettings !== false,
+					backend: {
+						ensureCollections: async () => {
+							for (const table of require_registry.hotUpdaterSchema.tables) {
+								if (table.internal) continue;
+								await db.createCollection(table.ormName).catch(ignoreExistingCollection);
+							}
+						},
+						ensureIndexes: async () => {
+							await ensureSettingsKeyIndex();
+							for (const table of require_registry.hotUpdaterSchema.tables) {
+								if (table.internal) continue;
+								const collection = db.collection(table.ormName);
+								const primaryKey = table.columns.find((column) => column.primaryKey);
+								if (!primaryKey) throw new Error(`MongoDB table ${table.ormName} does not define a primary key.`);
+								const idIndexName = `${table.ormName}_${primaryKey.ormName}_idx`;
+								const existingIdIndex = (await collection.listIndexes().toArray()).find(({ name }) => name === idIndexName);
+								if (existingIdIndex && existingIdIndex.unique !== true) await collection.dropIndex(idIndexName);
+								await collection.createIndex({ [primaryKey.ormName]: 1 }, {
+									name: idIndexName,
+									unique: true
+								});
+								for (const index of (table.indexes ?? []).filter((item) => require_registry.schemaIndexAppliesToProvider(item, "mongodb"))) await collection.createIndex(Object.fromEntries(index.columns.map((column) => [column, 1])), {
+									name: index.name,
+									...index.unique ? { unique: true } : {}
+								});
+							}
+						},
+						enforceSchema: async () => {
+							for (const [collection, validator] of [
+								["bundles", mongoBundleValidator],
+								["bundle_patches", mongoPatchValidator],
+								["releases", mongoReleaseValidator],
+								["release_catalogs", mongoReleaseCatalogValidator]
+							]) await db.command({
+								collMod: collection,
+								validationAction: "error",
+								validationLevel: "strict",
+								validator
+							});
+						},
+						updateVersion: async () => {
+							await settings.updateOne({ key: require_types.HOT_UPDATER_CORE_SCHEMA_KEY }, { $set: { value: require_types.HOT_UPDATER_SCHEMA_VERSION } }, { upsert: true });
+						}
+					}
+				});
+			}
+		};
+	};
+	return {
+		getVersion,
+		getNameVariants: async () => void 0,
+		next: async () => {
+			const { coreVersion } = await getSchemaVersions();
+			return require_fixedMigratorShared.isCurrentSchemaVersion(coreVersion) ? 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 !== "1.0.0") throw new Error(`Invalid version ${version}`);
+			return makeResult(options);
+		},
+		migrateToLatest: makeResult
+	};
+};
+//#endregion
+exports.createMongoMigrator = createMongoMigrator;