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

package/dist/db/fixedMigratorMongo.mjs

@@ -0,0 +1,319 @@
+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 { hotUpdaterSchema, schemaIndexAppliesToProvider } from "./schema/registry.mjs";
+import { executeMongoMigration } from "./mongoMigrationExecution.mjs";
+import { createMongoMigrationOperations } from "./schema/mongodb.mjs";
+//#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: ${HOT_UPDATER_SETTINGS_TABLE}(key)`,
+	type: "custom"
+});
+const createMongoMigrator = (client) => {
+	const settings = client.db().collection(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(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 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 = {}) => {
+		assertSupportedMigrationMode(options);
+		const { coreVersion, legacyCoreVersion } = await getSchemaVersions();
+		const settingsKeyIndexState = await getSettingsKeyIndexState();
+		if (settingsKeyIndexState === "non-unique") rejectNonUniqueSettingsKeyIndex();
+		if (isCurrentSchemaVersion(coreVersion)) {
+			if (settingsKeyIndexState === "unique") return getEmptyMigrationResult();
+			return {
+				...getEmptyMigrationResult(),
+				execute: ensureSettingsKeyIndex,
+				operations: [createSettingsKeyIndexOperation()]
+			};
+		}
+		assertCurrentOrEmptySchemaVersion(coreVersion ?? legacyCoreVersion);
+		const settingsOperation = options.updateSettings === false ? void 0 : {
+			type: "custom",
+			key: HOT_UPDATER_CORE_SCHEMA_KEY,
+			value: HOT_UPDATER_SCHEMA_VERSION
+		};
+		return {
+			operations: [createSettingsKeyIndexOperation(), ...createMongoMigrationOperations(settingsOperation)],
+			execute: async () => {
+				const db = client.db();
+				await executeMongoMigration({
+					updateSettings: options.updateSettings !== false,
+					backend: {
+						ensureCollections: async () => {
+							for (const table of hotUpdaterSchema.tables) {
+								if (table.internal) continue;
+								await db.createCollection(table.ormName).catch(ignoreExistingCollection);
+							}
+						},
+						ensureIndexes: async () => {
+							await ensureSettingsKeyIndex();
+							for (const table of 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) => 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: HOT_UPDATER_CORE_SCHEMA_KEY }, { $set: { value: HOT_UPDATER_SCHEMA_VERSION } }, { upsert: true });
+						}
+					}
+				});
+			}
+		};
+	};
+	return {
+		getVersion,
+		getNameVariants: async () => void 0,
+		next: async () => {
+			const { coreVersion } = await getSchemaVersions();
+			return isCurrentSchemaVersion(coreVersion) ? 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 !== "1.0.0") throw new Error(`Invalid version ${version}`);
+			return makeResult(options);
+		},
+		migrateToLatest: makeResult
+	};
+};
+//#endregion
+export { createMongoMigrator };

package/dist/db/fixedMigratorShared.cjs

@@ -0,0 +1,23 @@
+const require_types = require("../schema/types.cjs");
+//#region src/db/fixedMigratorShared.ts
+const getEmptyMigrationResult = () => ({
+	operations: [],
+	execute: async () => {},
+	getSQL: () => ""
+});
+const assertSupportedMigrationMode = (options) => {
+	if (options.mode === "from-database") throw new Error("Hot Updater migrations support only mode: 'from-schema'.");
+};
+const unsupportedSchemaUpgradeMessage = (version) => `Hot Updater v1 cannot migrate schema ${version} in place. Create a new empty database and run migrate or generate against schema ${require_types.HOT_UPDATER_SCHEMA_VERSION}.`;
+const assertCurrentOrEmptySchemaVersion = (currentVersion) => {
+	if (currentVersion !== void 0 && currentVersion !== "1.0.0") throw new Error(unsupportedSchemaUpgradeMessage(currentVersion));
+};
+const inferLegacyCoreSchemaVersion = (legacyVersion) => legacyVersion;
+const isCurrentSchemaVersion = (currentVersion) => currentVersion === require_types.HOT_UPDATER_SCHEMA_VERSION;
+//#endregion
+exports.assertCurrentOrEmptySchemaVersion = assertCurrentOrEmptySchemaVersion;
+exports.assertSupportedMigrationMode = assertSupportedMigrationMode;
+exports.getEmptyMigrationResult = getEmptyMigrationResult;
+exports.inferLegacyCoreSchemaVersion = inferLegacyCoreSchemaVersion;
+exports.isCurrentSchemaVersion = isCurrentSchemaVersion;
+exports.unsupportedSchemaUpgradeMessage = unsupportedSchemaUpgradeMessage;

package/dist/db/fixedMigratorShared.mjs

@@ -0,0 +1,18 @@
+import { HOT_UPDATER_SCHEMA_VERSION } from "../schema/types.mjs";
+//#region src/db/fixedMigratorShared.ts
+const getEmptyMigrationResult = () => ({
+	operations: [],
+	execute: async () => {},
+	getSQL: () => ""
+});
+const assertSupportedMigrationMode = (options) => {
+	if (options.mode === "from-database") throw new Error("Hot Updater migrations support only mode: 'from-schema'.");
+};
+const unsupportedSchemaUpgradeMessage = (version) => `Hot Updater v1 cannot migrate schema ${version} in place. Create a new empty database and run migrate or generate against schema ${HOT_UPDATER_SCHEMA_VERSION}.`;
+const assertCurrentOrEmptySchemaVersion = (currentVersion) => {
+	if (currentVersion !== void 0 && currentVersion !== "1.0.0") throw new Error(unsupportedSchemaUpgradeMessage(currentVersion));
+};
+const inferLegacyCoreSchemaVersion = (legacyVersion) => legacyVersion;
+const isCurrentSchemaVersion = (currentVersion) => currentVersion === HOT_UPDATER_SCHEMA_VERSION;
+//#endregion
+export { assertCurrentOrEmptySchemaVersion, assertSupportedMigrationMode, getEmptyMigrationResult, inferLegacyCoreSchemaVersion, isCurrentSchemaVersion, unsupportedSchemaUpgradeMessage };

package/dist/db/mongoMigrationExecution.cjs

@@ -0,0 +1,11 @@
+//#region src/db/mongoMigrationExecution.ts
+const executeMongoMigration = async ({ backend, updateSettings }) => {
+	await backend.ensureCollections();
+	await backend.backfillData?.();
+	await backend.validateData?.();
+	await backend.ensureIndexes();
+	await backend.enforceSchema?.();
+	if (updateSettings) await backend.updateVersion();
+};
+//#endregion
+exports.executeMongoMigration = executeMongoMigration;

package/dist/db/mongoMigrationExecution.mjs

@@ -0,0 +1,11 @@
+//#region src/db/mongoMigrationExecution.ts
+const executeMongoMigration = async ({ backend, updateSettings }) => {
+	await backend.ensureCollections();
+	await backend.backfillData?.();
+	await backend.validateData?.();
+	await backend.ensureIndexes();
+	await backend.enforceSchema?.();
+	if (updateSettings) await backend.updateVersion();
+};
+//#endregion
+export { executeMongoMigration };

package/dist/db/releaseCatalog.cjs

@@ -0,0 +1,66 @@
+require("../_virtual/_rolldown/runtime.cjs");
+const require_updateArtifacts = require("./updateArtifacts.cjs");
+let _hot_updater_plugin_core = require("@hot-updater/plugin-core");
+let _hot_updater_core = require("@hot-updater/core");
+//#region src/db/releaseCatalog.ts
+const parseCompiledCatalog = (payload, strategy) => {
+	const parsed = JSON.parse(payload);
+	if (typeof parsed !== "object" || parsed === null || Reflect.get(parsed, "schemaVersion") !== _hot_updater_core.RELEASE_CATALOG_SCHEMA_VERSION || Reflect.get(parsed, "strategy") !== strategy || Reflect.get(parsed, "fallbackPolicy") !== _hot_updater_core.RELEASE_CATALOG_FALLBACK_POLICY || !Array.isArray(Reflect.get(parsed, "releaseDescriptors"))) throw new Error("Stored Release catalog payload is invalid");
+	if (strategy === "APP_VERSION" && !Array.isArray(Reflect.get(parsed, "segments"))) throw new Error("Stored app-version Release catalog is invalid");
+	if (strategy === "FINGERPRINT" && !Array.isArray(Reflect.get(parsed, "releaseIndexes"))) throw new Error("Stored fingerprint Release catalog is invalid");
+	return parsed;
+};
+const createReleaseCatalogReader = (database) => async (input) => {
+	const scopeKey = input.strategy === "APP_VERSION" ? (0, _hot_updater_core.createReleaseCatalogScopeKey)({
+		channelKey: input.channelKey,
+		platform: input.platform,
+		strategy: "APP_VERSION"
+	}) : (0, _hot_updater_core.createReleaseCatalogScopeKey)({
+		channelKey: input.channelKey,
+		fingerprintHash: input.fingerprintHash,
+		platform: input.platform,
+		strategy: "FINGERPRINT"
+	});
+	const row = await database.models.releaseCatalogs.findByScopeKey(scopeKey);
+	if (row === null || row.platform !== input.platform || row.strategy !== input.strategy || row.channel_key !== input.channelKey || row.scope_key !== scopeKey || row.fingerprint_hash !== (input.strategy === "FINGERPRINT" ? input.fingerprintHash : null)) return null;
+	const compiled = parseCompiledCatalog(row.payload, input.strategy);
+	const releases = (0, _hot_updater_plugin_core.projectCompiledCatalog)(compiled, input.strategy === "APP_VERSION" ? input.appVersion : void 0);
+	const rollbackReleases = (0, _hot_updater_plugin_core.projectCompiledRollbackCatalog)(compiled, input.strategy === "APP_VERSION" ? input.appVersion : void 0);
+	return {
+		catalogId: row.catalog_id,
+		catalogHash: row.catalog_hash,
+		fallbackPolicy: _hot_updater_core.RELEASE_CATALOG_FALLBACK_POLICY,
+		generation: row.generation,
+		releases,
+		rollbackReleases,
+		schemaVersion: _hot_updater_core.RELEASE_CATALOG_SCHEMA_VERSION,
+		scopeKey
+	};
+};
+const createArtifactResolver = (input) => {
+	const databaseClient = (0, _hot_updater_plugin_core.createDatabaseClient)(input.database);
+	return async (targetBundleId, currentBundleId) => {
+		const [targetBundle, currentBundle] = await Promise.all([databaseClient.getBundleById(targetBundleId), currentBundleId === _hot_updater_core.NIL_UUID ? null : databaseClient.getBundleById(currentBundleId)]);
+		if (targetBundle === null) return null;
+		const fileUrl = await input.resolveFileUrl(targetBundle.storageUri);
+		const base = {
+			fileHash: targetBundle.fileHash,
+			fileUrl
+		};
+		if (input.readStorageText === void 0) return base;
+		const manifest = await require_updateArtifacts.resolveManifestArtifacts({
+			archiveUrlUsable: fileUrl !== null,
+			currentBundle,
+			readStorageText: input.readStorageText,
+			resolveFileUrl: input.resolveFileUrl,
+			targetBundle
+		});
+		return manifest === null ? base : {
+			...base,
+			...manifest
+		};
+	};
+};
+//#endregion
+exports.createArtifactResolver = createArtifactResolver;
+exports.createReleaseCatalogReader = createReleaseCatalogReader;

package/dist/db/releaseCatalog.d.cts

@@ -0,0 +1,17 @@
+import { ArtifactInfo, ReleaseCatalog } from "@hot-updater/core";
+import { DatabasePlugin } from "@hot-updater/plugin-core";
+
+//#region src/db/releaseCatalog.d.ts
+type ReleaseCatalogRequest = {
+  readonly strategy: "APP_VERSION";
+  readonly platform: "ios" | "android";
+  readonly channelKey: string;
+  readonly appVersion: string;
+} | {
+  readonly strategy: "FINGERPRINT";
+  readonly platform: "ios" | "android";
+  readonly channelKey: string;
+  readonly fingerprintHash: string;
+};
+//#endregion
+export { ReleaseCatalogRequest };

package/dist/db/releaseCatalog.d.mts

@@ -0,0 +1,17 @@
+import { DatabasePlugin } from "@hot-updater/plugin-core";
+import { ArtifactInfo, ReleaseCatalog } from "@hot-updater/core";
+
+//#region src/db/releaseCatalog.d.ts
+type ReleaseCatalogRequest = {
+  readonly strategy: "APP_VERSION";
+  readonly platform: "ios" | "android";
+  readonly channelKey: string;
+  readonly appVersion: string;
+} | {
+  readonly strategy: "FINGERPRINT";
+  readonly platform: "ios" | "android";
+  readonly channelKey: string;
+  readonly fingerprintHash: string;
+};
+//#endregion
+export { ReleaseCatalogRequest };

package/dist/db/releaseCatalog.mjs

@@ -0,0 +1,64 @@
+import { resolveManifestArtifacts } from "./updateArtifacts.mjs";
+import { createDatabaseClient, projectCompiledCatalog, projectCompiledRollbackCatalog } from "@hot-updater/plugin-core";
+import { NIL_UUID, RELEASE_CATALOG_FALLBACK_POLICY, RELEASE_CATALOG_SCHEMA_VERSION, createReleaseCatalogScopeKey } from "@hot-updater/core";
+//#region src/db/releaseCatalog.ts
+const parseCompiledCatalog = (payload, strategy) => {
+	const parsed = JSON.parse(payload);
+	if (typeof parsed !== "object" || parsed === null || Reflect.get(parsed, "schemaVersion") !== RELEASE_CATALOG_SCHEMA_VERSION || Reflect.get(parsed, "strategy") !== strategy || Reflect.get(parsed, "fallbackPolicy") !== RELEASE_CATALOG_FALLBACK_POLICY || !Array.isArray(Reflect.get(parsed, "releaseDescriptors"))) throw new Error("Stored Release catalog payload is invalid");
+	if (strategy === "APP_VERSION" && !Array.isArray(Reflect.get(parsed, "segments"))) throw new Error("Stored app-version Release catalog is invalid");
+	if (strategy === "FINGERPRINT" && !Array.isArray(Reflect.get(parsed, "releaseIndexes"))) throw new Error("Stored fingerprint Release catalog is invalid");
+	return parsed;
+};
+const createReleaseCatalogReader = (database) => async (input) => {
+	const scopeKey = input.strategy === "APP_VERSION" ? createReleaseCatalogScopeKey({
+		channelKey: input.channelKey,
+		platform: input.platform,
+		strategy: "APP_VERSION"
+	}) : createReleaseCatalogScopeKey({
+		channelKey: input.channelKey,
+		fingerprintHash: input.fingerprintHash,
+		platform: input.platform,
+		strategy: "FINGERPRINT"
+	});
+	const row = await database.models.releaseCatalogs.findByScopeKey(scopeKey);
+	if (row === null || row.platform !== input.platform || row.strategy !== input.strategy || row.channel_key !== input.channelKey || row.scope_key !== scopeKey || row.fingerprint_hash !== (input.strategy === "FINGERPRINT" ? input.fingerprintHash : null)) return null;
+	const compiled = parseCompiledCatalog(row.payload, input.strategy);
+	const releases = projectCompiledCatalog(compiled, input.strategy === "APP_VERSION" ? input.appVersion : void 0);
+	const rollbackReleases = projectCompiledRollbackCatalog(compiled, input.strategy === "APP_VERSION" ? input.appVersion : void 0);
+	return {
+		catalogId: row.catalog_id,
+		catalogHash: row.catalog_hash,
+		fallbackPolicy: RELEASE_CATALOG_FALLBACK_POLICY,
+		generation: row.generation,
+		releases,
+		rollbackReleases,
+		schemaVersion: RELEASE_CATALOG_SCHEMA_VERSION,
+		scopeKey
+	};
+};
+const createArtifactResolver = (input) => {
+	const databaseClient = createDatabaseClient(input.database);
+	return async (targetBundleId, currentBundleId) => {
+		const [targetBundle, currentBundle] = await Promise.all([databaseClient.getBundleById(targetBundleId), currentBundleId === NIL_UUID ? null : databaseClient.getBundleById(currentBundleId)]);
+		if (targetBundle === null) return null;
+		const fileUrl = await input.resolveFileUrl(targetBundle.storageUri);
+		const base = {
+			fileHash: targetBundle.fileHash,
+			fileUrl
+		};
+		if (input.readStorageText === void 0) return base;
+		const manifest = await resolveManifestArtifacts({
+			archiveUrlUsable: fileUrl !== null,
+			currentBundle,
+			readStorageText: input.readStorageText,
+			resolveFileUrl: input.resolveFileUrl,
+			targetBundle
+		});
+		return manifest === null ? base : {
+			...base,
+			...manifest
+		};
+	};
+};
+//#endregion
+export { createArtifactResolver, createReleaseCatalogReader };

package/dist/db/schema/mongodb.cjs

@@ -3,14 +3,22 @@ const require_sql = require("./sql.cjs");
 //#region src/db/schema/mongodb.ts
 const createMongoMigrationOperations = (settingsOperation) => [
 	...require_sql.hotUpdaterCreateTableOperations,
-	{
-		type: "custom",
-		sql: "create index bundles_id_idx on bundles(id)"
-	},
+	...require_registry.hotUpdaterSchema.tables.filter((table) => !table.internal).map((table) => {
+		const primaryKey = table.columns.find((column) => column.primaryKey);
+		if (!primaryKey) throw new Error(`MongoDB table ${table.ormName} does not define a primary key.`);
+		return {
+			description: `Create unique MongoDB index: ${table.ormName}_${primaryKey.ormName}_idx on ${table.ormName}(${primaryKey.ormName})`,
+			type: "custom"
+		};
+	}),
 	...require_registry.hotUpdaterSchema.tables.flatMap((table) => (table.indexes ?? []).filter((index) => require_registry.schemaIndexAppliesToProvider(index, "mongodb")).map((index) => ({
-		type: "custom",
-		sql: `create index ${index.name} on ${table.ormName}(${index.columns.join(", ")})`
+		description: `Create ${index.unique ? "unique " : ""}MongoDB index: ${index.name} on ${table.ormName}(${index.columns.join(", ")})`,
+		type: "custom"
 	}))),
+	{
+		description: "Enforce final MongoDB Bundle, Release, and catalog schemas",
+		type: "custom"
+	},
 	...settingsOperation ? [settingsOperation] : []
 ];
 //#endregion

package/dist/db/schema/mongodb.mjs

@@ -3,14 +3,22 @@ import { hotUpdaterCreateTableOperations } from "./sql.mjs";
 //#region src/db/schema/mongodb.ts
 const createMongoMigrationOperations = (settingsOperation) => [
 	...hotUpdaterCreateTableOperations,
-	{
-		type: "custom",
-		sql: "create index bundles_id_idx on bundles(id)"
-	},
+	...hotUpdaterSchema.tables.filter((table) => !table.internal).map((table) => {
+		const primaryKey = table.columns.find((column) => column.primaryKey);
+		if (!primaryKey) throw new Error(`MongoDB table ${table.ormName} does not define a primary key.`);
+		return {
+			description: `Create unique MongoDB index: ${table.ormName}_${primaryKey.ormName}_idx on ${table.ormName}(${primaryKey.ormName})`,
+			type: "custom"
+		};
+	}),
 	...hotUpdaterSchema.tables.flatMap((table) => (table.indexes ?? []).filter((index) => schemaIndexAppliesToProvider(index, "mongodb")).map((index) => ({
-		type: "custom",
-		sql: `create index ${index.name} on ${table.ormName}(${index.columns.join(", ")})`
+		description: `Create ${index.unique ? "unique " : ""}MongoDB index: ${index.name} on ${table.ormName}(${index.columns.join(", ")})`,
+		type: "custom"
 	}))),
+	{
+		description: "Enforce final MongoDB Bundle, Release, and catalog schemas",
+		type: "custom"
+	},
 	...settingsOperation ? [settingsOperation] : []
 ];
 //#endregion

package/dist/db/schema/registry.cjs

@@ -1,7 +1,6 @@
 const require_index = require("../../schema/index.cjs");
 //#region src/db/schema/registry.ts
 const hotUpdaterSchema = require_index.hotUpdaterSchemaVersions[require_index.hotUpdaterSchemaVersions.length - 1];
-const getSchemaVersionIndex = (version) => require_index.hotUpdaterSchemaVersions.findIndex((schema) => schema.version === version);
 const getHotUpdaterSchemaVersion = (version) => {
 	const schema = require_index.hotUpdaterSchemaVersions.find((item) => item.version === version);
 	if (!schema) throw new Error(`Unsupported Hot Updater schema version: ${version}`);
@@ -17,7 +16,6 @@ const schemaIndexAppliesToProvider = (index, provider) => !index.providers || in
 //#endregion
 exports.getHotUpdaterSchemaVersion = getHotUpdaterSchemaVersion;
 exports.getSchemaColumn = getSchemaColumn;
-exports.getSchemaVersionIndex = getSchemaVersionIndex;
 exports.hotUpdaterDataTables = hotUpdaterDataTables;
 exports.hotUpdaterSchema = hotUpdaterSchema;
 exports.schemaIndexAppliesToProvider = schemaIndexAppliesToProvider;

package/dist/db/schema/registry.mjs

@@ -1,7 +1,6 @@
 import { hotUpdaterSchemaVersions } from "../../schema/index.mjs";
 //#region src/db/schema/registry.ts
 const hotUpdaterSchema = hotUpdaterSchemaVersions[hotUpdaterSchemaVersions.length - 1];
-const getSchemaVersionIndex = (version) => hotUpdaterSchemaVersions.findIndex((schema) => schema.version === version);
 const getHotUpdaterSchemaVersion = (version) => {
 	const schema = hotUpdaterSchemaVersions.find((item) => item.version === version);
 	if (!schema) throw new Error(`Unsupported Hot Updater schema version: ${version}`);
@@ -15,4 +14,4 @@ const getSchemaColumn = (table, name) => {
 const hotUpdaterDataTables = hotUpdaterSchema.tables.filter((table) => !table.internal);
 const schemaIndexAppliesToProvider = (index, provider) => !index.providers || index.providers.includes(provider);
 //#endregion
-export { getHotUpdaterSchemaVersion, getSchemaColumn, getSchemaVersionIndex, hotUpdaterDataTables, hotUpdaterSchema, schemaIndexAppliesToProvider };
+export { getHotUpdaterSchemaVersion, getSchemaColumn, hotUpdaterDataTables, hotUpdaterSchema, schemaIndexAppliesToProvider };