@hot-updater/server 1.0.0-rc.2 → 1.0.0-rc.21

package/dist/db/databasePluginCore.mjs

@@ -1,137 +0,0 @@
-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,79 +0,0 @@
-const require_types = require("../schema/types.cjs");
-const require_fixedMigratorShared = require("./fixedMigratorShared.cjs");
-const require_sql = require("./schema/sql.cjs");
-const require_sqlOperations = require("./schema/sqlOperations.cjs");
-const require_sqlMigrationExecution = require("./sqlMigrationExecution.cjs");
-const require_fixedMigratorMongo = require("./fixedMigratorMongo.cjs");
-let kysely = require("kysely");
-//#region src/db/fixedMigrator.ts
-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 createKyselyMigrator = ({ db, provider, relationMode = "foreign-keys" }) => {
-	const getSetting = async (key) => {
-		try {
-			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 = {}) => {
-		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 statements = [...require_sql.createTableSql(provider, relationMode), settingsStatement];
-		return {
-			operations: require_sqlOperations.createSqlCreateOperations(provider, relationMode, settingsOperation),
-			getSQL: () => statements.map((statement) => `${statement};`).join("\n\n"),
-			execute: () => require_sqlMigrationExecution.executeMigrationStatements({
-				db,
-				provider,
-				statements
-			})
-		};
-	};
-	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.createKyselyMigrator = createKyselyMigrator;
-exports.createMongoMigrator = require_fixedMigratorMongo.createMongoMigrator;

package/dist/db/fixedMigrator.mjs

@@ -1,78 +0,0 @@
-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 { createSqlCreateOperations, getSettingsInsertSql } from "./schema/sqlOperations.mjs";
-import { executeMigrationStatements } from "./sqlMigrationExecution.mjs";
-import { createMongoMigrator } from "./fixedMigratorMongo.mjs";
-import { sql } from "kysely";
-//#region src/db/fixedMigrator.ts
-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 createKyselyMigrator = ({ db, provider, relationMode = "foreign-keys" }) => {
-	const getSetting = async (key) => {
-		try {
-			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 { 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 statements = [...createTableSql(provider, relationMode), settingsStatement];
-		return {
-			operations: createSqlCreateOperations(provider, relationMode, settingsOperation),
-			getSQL: () => statements.map((statement) => `${statement};`).join("\n\n"),
-			execute: () => executeMigrationStatements({
-				db,
-				provider,
-				statements
-			})
-		};
-	};
-	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 { createKyselyMigrator, createMongoMigrator };

package/dist/db/fixedMigratorMongo.cjs

@@ -1,321 +0,0 @@
-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 isInsights = table.ormName === "bundle_events" || table.ormName === "bundle_installations";
-								const collection = db.collection(table.ormName);
-								const collation = isInsights ? { locale: "simple" } : void 0;
-								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`;
-								await collection.createIndex({ [primaryKey.ormName]: 1 }, {
-									name: idIndexName,
-									unique: true,
-									...collation ? { collation } : {}
-								});
-								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 } : {},
-									...collation ? { collation } : {}
-								});
-							}
-						},
-						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;