@rpcbase/migrations 0.1.0 → 0.2.0

package/dist/assertCurrent.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"assertCurrent.d.ts","sourceRoot":"","sources":["../src/assertCurrent.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EACV,yBAAyB,EACzB,yBAAyB,EACzB,aAAa,EACb,oBAAoB,EACrB,MAAM,SAAS,CAAA;AAGhB,eAAO,MAAM,uBAAuB,GAClC,UAAU,yBAAyB,EACnC,UAAU,yBAAyB,EACnC,UAAS,oBAAyB,KACjC,OAAO,CAAC,aAAa,CAYvB,CAAA"}
+{"version":3,"file":"assertCurrent.d.ts","sourceRoot":"","sources":["../src/assertCurrent.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EACV,yBAAyB,EACzB,yBAAyB,EACzB,aAAa,EACb,oBAAoB,EACrB,MAAM,SAAS,CAAA;AAGhB,eAAO,MAAM,uBAAuB,GAClC,UAAU,yBAAyB,EACnC,UAAU,yBAAyB,EACnC,UAAS,oBAAyB,KACjC,OAAO,CAAC,aAAa,CAcvB,CAAA"}

package/dist/databaseProvider.d.ts

@@ -4,6 +4,7 @@ export type CreateMigrationDatabaseProviderOptions = {
     client: MongoClient;
     appName: string;
     tenantCollection?: string;
+    initializingTenantStaleAfterMs?: number;
     filesystemRequired?: (tenantId: string, signal: AbortSignal) => boolean | Promise<boolean>;
 };
 export declare const createMigrationDatabaseProvider: (options: CreateMigrationDatabaseProviderOptions) => MigrationDatabaseProvider;

package/dist/databaseProvider.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"databaseProvider.d.ts","sourceRoot":"","sources":["../src/databaseProvider.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,EAAE,EAAE,WAAW,EAAE,MAAM,SAAS,CAAA;AAE9C,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,SAAS,CAAA;AAiBxD,MAAM,MAAM,sCAAsC,GAAG;IACnD,MAAM,EAAE,WAAW,CAAA;IACnB,OAAO,EAAE,MAAM,CAAA;IACf,gBAAgB,CAAC,EAAE,MAAM,CAAA;IACzB,kBAAkB,CAAC,EAAE,CAAC,QAAQ,EAAE,MAAM,EAAE,MAAM,EAAE,WAAW,KAAK,OAAO,GAAG,OAAO,CAAC,OAAO,CAAC,CAAA;CAC3F,CAAA;AAED,eAAO,MAAM,+BAA+B,GAC1C,SAAS,sCAAsC,KAC9C,yBAuCF,CAAA;AAED,eAAO,MAAM,wBAAwB,GAAI,IAAI,EAAE,KAAG,MAAyB,CAAA"}
+{"version":3,"file":"databaseProvider.d.ts","sourceRoot":"","sources":["../src/databaseProvider.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,EAAE,EAAE,WAAW,EAAE,MAAM,SAAS,CAAA;AAE9C,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,SAAS,CAAA;AAiBxD,MAAM,MAAM,sCAAsC,GAAG;IACnD,MAAM,EAAE,WAAW,CAAA;IACnB,OAAO,EAAE,MAAM,CAAA;IACf,gBAAgB,CAAC,EAAE,MAAM,CAAA;IACzB,8BAA8B,CAAC,EAAE,MAAM,CAAA;IACvC,kBAAkB,CAAC,EAAE,CAAC,QAAQ,EAAE,MAAM,EAAE,MAAM,EAAE,WAAW,KAAK,OAAO,GAAG,OAAO,CAAC,OAAO,CAAC,CAAA;CAC3F,CAAA;AAED,eAAO,MAAM,+BAA+B,GAC1C,SAAS,sCAAsC,KAC9C,yBAkEF,CAAA;AAED,eAAO,MAAM,wBAAwB,GAAI,IAAI,EAAE,KAAG,MAAyB,CAAA"}

package/dist/diffResources.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"diffResources.d.ts","sourceRoot":"","sources":["../src/diffResources.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAKV,cAAc,EACd,kBAAkB,EAEnB,MAAM,SAAS,CAAA;AAwChB,eAAO,MAAM,kBAAkB,GAC7B,QAAQ,cAAc,EACtB,OAAO,cAAc,KACpB,kBAoBF,CAAA"}
+{"version":3,"file":"diffResources.d.ts","sourceRoot":"","sources":["../src/diffResources.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAKV,cAAc,EACd,kBAAkB,EAEnB,MAAM,SAAS,CAAA;AAyChB,eAAO,MAAM,kBAAkB,GAC7B,QAAQ,cAAc,EACtB,OAAO,cAAc,KACpB,kBAoBF,CAAA"}

package/dist/helpers.d.ts

@@ -1,8 +1,9 @@
 import { Db } from 'mongodb';
-import { MigrationHelpers } from './types';
+import { MigrationHelpers, MongoResources } from './types';
 export type CreateMigrationHelpersOptions = {
     searchTimeoutMs?: number;
     searchPollIntervalMs?: number;
 };
 export declare const createMigrationHelpers: (db: Db, signal: AbortSignal, options?: CreateMigrationHelpersOptions) => MigrationHelpers;
+export declare const reconcileRuntimeIndexOptions: (db: Db, resources: MongoResources, signal: AbortSignal) => Promise<void>;
 //# sourceMappingURL=helpers.d.ts.map

package/dist/helpers.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"helpers.d.ts","sourceRoot":"","sources":["../src/helpers.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,EAAE,EAAY,MAAM,SAAS,CAAA;AAI3C,OAAO,KAAK,EAAE,gBAAgB,EAAkB,MAAM,SAAS,CAAA;AAwC/D,MAAM,MAAM,6BAA6B,GAAG;IAC1C,eAAe,CAAC,EAAE,MAAM,CAAA;IACxB,oBAAoB,CAAC,EAAE,MAAM,CAAA;CAC9B,CAAA;AAED,eAAO,MAAM,sBAAsB,GACjC,IAAI,EAAE,EACN,QAAQ,WAAW,EACnB,UAAS,6BAAkC,KAC1C,gBAoJF,CAAA"}
+{"version":3,"file":"helpers.d.ts","sourceRoot":"","sources":["../src/helpers.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,EAAE,EAAY,MAAM,SAAS,CAAA;AAI3C,OAAO,KAAK,EAAE,gBAAgB,EAAE,cAAc,EAAE,MAAM,SAAS,CAAA;AAwC/D,MAAM,MAAM,6BAA6B,GAAG;IAC1C,eAAe,CAAC,EAAE,MAAM,CAAA;IACxB,oBAAoB,CAAC,EAAE,MAAM,CAAA;CAC9B,CAAA;AAED,eAAO,MAAM,sBAAsB,GACjC,IAAI,EAAE,EACN,QAAQ,WAAW,EACnB,UAAS,6BAAkC,KAC1C,gBAwJF,CAAA;AAED,eAAO,MAAM,4BAA4B,GACvC,IAAI,EAAE,EACN,WAAW,cAAc,EACzB,QAAQ,WAAW,KAClB,OAAO,CAAC,IAAI,CAoCd,CAAA"}

package/dist/index.js

@@ -20,6 +20,7 @@ var scopes = /* @__PURE__ */ new Set([
 	"tenant",
 	"filesystem"
 ]);
+var runtimeIndexOptions = /* @__PURE__ */ new Set(["expireAfterSeconds"]);
 var assertName = (value, label) => {
 	const normalized = value.trim();
 	if (!normalized) throw new Error(`${label} is required`);
@@ -59,12 +60,18 @@ var normalizeCollection = (resource) => {
 var normalizeIndex = (resource) => {
 	assertScope(resource.scope);
 	if (Object.keys(resource.key).length === 0) throw new Error("Index key cannot be empty");
+	const optionNames = new Set(Object.keys(resource.options ?? {}));
+	const unsupportedRuntimeOption = Object.keys(resource.runtimeOptions ?? {}).find((name) => !runtimeIndexOptions.has(name));
+	if (unsupportedRuntimeOption) throw new Error(`Unsupported runtime-managed index option: ${unsupportedRuntimeOption}`);
+	const overlappingRuntimeOption = Object.keys(resource.runtimeOptions ?? {}).find((name) => optionNames.has(name));
+	if (overlappingRuntimeOption) throw new Error(`Index option ${overlappingRuntimeOption} cannot be both fixed and runtime-managed`);
 	return {
 		scope: resource.scope,
 		collection: assertName(resource.collection, "Index collection"),
 		name: assertName(resource.name, "Index name"),
 		key: structuredClone(resource.key),
-		...resource.options ? { options: copyDocument(resource.options) } : {}
+		...resource.options ? { options: copyDocument(resource.options) } : {},
+		...resource.runtimeOptions ? { runtimeOptions: copyDocument(resource.runtimeOptions) } : {}
 	};
 };
 var normalizeSearchIndex = (resource) => {
@@ -95,7 +102,8 @@ var checksumInput = (resources) => ({
 	indexes: resources.indexes.map((resource) => ({
 		...resource,
 		key: Object.entries(resource.key),
-		options: resource.options ?? {}
+		options: resource.options ?? {},
+		...resource.runtimeOptions ? { runtimeOptions: Object.keys(resource.runtimeOptions).sort() } : {}
 	})),
 	searchIndexes: resources.searchIndexes,
 	collectionValidators: resources.collectionValidators
@@ -123,15 +131,18 @@ var mergeMongoResources = (resourceSets) => {
 	const indexes = /* @__PURE__ */ new Map();
 	const searchIndexes = /* @__PURE__ */ new Map();
 	const validators = /* @__PURE__ */ new Map();
-	const merge = (target, resource, identity, label) => {
+	const merge = (target, resource, identity, label, comparisonValue = (value) => value) => {
 		const key = identity(resource);
 		const previous = target.get(key);
-		if (previous && canonicalStringify(previous) !== canonicalStringify(resource)) throw new Error(`Conflicting ${label} resource across migration sources: ${key}`);
+		if (previous && canonicalStringify(comparisonValue(previous)) !== canonicalStringify(comparisonValue(resource))) throw new Error(`Conflicting ${label} resource across migration sources: ${key}`);
 		target.set(key, resource);
 	};
 	for (const resources of resourceSets) {
 		for (const resource of resources.collections) merge(collections, resource, collectionIdentity$1, "collection");
-		for (const resource of resources.indexes) merge(indexes, resource, indexIdentity$1, "index");
+		for (const resource of resources.indexes) merge(indexes, resource, indexIdentity$1, "index", (value) => ({
+			...value,
+			key: Object.entries(value.key)
+		}));
 		for (const resource of resources.searchIndexes) merge(searchIndexes, resource, indexIdentity$1, "Search index");
 		for (const resource of resources.collectionValidators) merge(validators, resource, validatorIdentity$1, "collection validator");
 	}
@@ -149,7 +160,8 @@ var indexIdentity = (resource) => `${resource.scope}:${resource.collection}:${re
 var validatorIdentity = (resource) => `${resource.scope}:${resource.collection}`;
 var indexComparisonValue = (resource) => ({
 	...resource,
-	key: Object.entries(resource.key)
+	key: Object.entries(resource.key),
+	runtimeOptions: Object.keys(resource.runtimeOptions ?? {}).sort()
 });
 var diffSet = (before, after, identity, comparisonValue = (resource) => resource) => {
 	const beforeById = new Map(before.map((resource) => [identity(resource), resource]));
@@ -508,7 +520,10 @@ var inspectMongoResources = async (db, resources, options = {}) => {
 			continue;
 		}
 		const actualDefinition = normalizeIndexDefinition(actual.key ?? {}, actual, expected.key);
-		const expectedDefinition = normalizeIndexDefinition(expected.key, expected.options ?? {});
+		const expectedDefinition = normalizeIndexDefinition(expected.key, {
+			...expected.options ?? {},
+			...expected.runtimeOptions ?? {}
+		});
 		if (!same$1(actualDefinition.key, expectedDefinition.key)) divergences.push({
 			code: "index_key_mismatch",
 			scope: expected.scope,
@@ -520,15 +535,20 @@ var inspectMongoResources = async (db, resources, options = {}) => {
 		});
 		const expectedOptions = expectedDefinition.options;
 		const actualOptions = actualDefinition.options;
-		if (!same$1(actualOptions, expectedOptions)) divergences.push({
-			code: "index_options_mismatch",
-			scope: expected.scope,
-			collection: expected.collection,
-			resource: expected.name,
-			expected: expectedOptions,
-			actual: actualOptions,
-			message: message(expected.collection, expected.name, "index options differ")
-		});
+		if (!same$1(actualOptions, expectedOptions)) {
+			const runtimeOptionNames = new Set(Object.keys(expected.runtimeOptions ?? {}));
+			const fixedOptions = (indexOptions) => Object.fromEntries(Object.entries(indexOptions).filter(([name]) => !runtimeOptionNames.has(name)));
+			const runtimeOnly = runtimeOptionNames.size > 0 && same$1(fixedOptions(actualOptions), fixedOptions(expectedOptions));
+			divergences.push({
+				code: runtimeOnly ? "runtime_index_options_mismatch" : "index_options_mismatch",
+				scope: expected.scope,
+				collection: expected.collection,
+				resource: expected.name,
+				expected: expectedOptions,
+				actual: actualOptions,
+				message: message(expected.collection, expected.name, "index options differ")
+			});
+		}
 	}
 	for (const expected of resources.collectionValidators) {
 		const collection = collectionsByName.get(expected.collection);
@@ -757,12 +777,45 @@ var createMigrationHelpers = (db, signal, options = {}) => {
 			});
 			for (const index of resources.indexes) await ensureIndex(index.collection, index.key, {
 				name: index.name,
-				...index.options ?? {}
+				...index.options ?? {},
+				...index.runtimeOptions ?? {}
 			});
 			for (const index of resources.searchIndexes) await ensureSearchIndex(index.collection, index.name, index.definition);
 		}
 	};
 };
+var reconcileRuntimeIndexOptions = async (db, resources, signal) => {
+	for (const index of resources.indexes) {
+		const runtimeOptions = index.runtimeOptions ?? {};
+		if (Object.keys(runtimeOptions).length === 0) continue;
+		signal.throwIfAborted();
+		let indexes;
+		try {
+			indexes = await db.collection(index.collection).listIndexes().toArray();
+		} catch (error) {
+			if (namespaceMissing(error)) continue;
+			throw error;
+		}
+		const actual = indexes.find((candidate) => candidate.name === index.name);
+		if (!actual) continue;
+		const actualDefinition = normalizeIndexDefinition(actual.key ?? {}, actual, index.key);
+		const expectedDefinition = normalizeIndexDefinition(index.key, {
+			...index.options ?? {},
+			...runtimeOptions
+		});
+		const runtimeOptionNames = new Set(Object.keys(runtimeOptions));
+		const fixedOptions = (options) => Object.fromEntries(Object.entries(options).filter(([name]) => !runtimeOptionNames.has(name)));
+		if (!same(actualDefinition.key, expectedDefinition.key) || !same(fixedOptions(actualDefinition.options), fixedOptions(expectedDefinition.options))) continue;
+		if (!Object.keys(runtimeOptions).some((name) => !same(actualDefinition.options[name], expectedDefinition.options[name]))) continue;
+		await db.command({
+			collMod: index.collection,
+			index: {
+				name: index.name,
+				...runtimeOptions
+			}
+		});
+	}
+};
 //#endregion
 //#region src/errors.ts
 var MigrationIntegrityError = class extends Error {
@@ -811,11 +864,21 @@ var createMigrationDatabaseProvider = (options) => {
 	const appName = normalizeAppName(options.appName);
 	const globalDbName = `${appName}-global-db`;
 	const tenantCollection = options.tenantCollection?.trim() || "rbtenants";
+	const initializingTenantStaleAfterMs = options.initializingTenantStaleAfterMs ?? 5 * 6e4;
+	if (!Number.isFinite(initializingTenantStaleAfterMs) || initializingTenantStaleAfterMs < 0) throw new Error("initializingTenantStaleAfterMs must be a non-negative finite number");
+	const staleInitializingFilter = () => ({
+		provisioningStatus: "initializing",
+		$or: [{ provisioningStartedAt: { $exists: false } }, { provisioningStartedAt: { $lte: new Date(Date.now() - initializingTenantStaleAfterMs) } }]
+	});
 	return {
 		global: () => options.client.db(globalDbName),
 		tenantIds: async (signal) => {
 			signal.throwIfAborted();
-			const documents = await options.client.db(globalDbName).collection(tenantCollection).find({ $or: [{ provisioningStatus: { $exists: false } }, { provisioningStatus: "active" }] }, { projection: { tenantId: 1 } }).sort({ tenantId: 1 }).toArray();
+			const documents = await options.client.db(globalDbName).collection(tenantCollection).find({ $or: [
+				{ provisioningStatus: { $exists: false } },
+				{ provisioningStatus: "active" },
+				staleInitializingFilter()
+			] }, { projection: { tenantId: 1 } }).sort({ tenantId: 1 }).toArray();
 			signal.throwIfAborted();
 			return [...new Set(documents.flatMap((document) => typeof document.tenantId === "string" && document.tenantId.trim() ? [normalizeTenantId(document.tenantId)] : []))];
 		},
@@ -827,6 +890,21 @@ var createMigrationDatabaseProvider = (options) => {
 			return Boolean(tenant);
 		},
 		tenant: (tenantId) => options.client.db(`${appName}-${normalizeTenantId(tenantId)}-db`),
+		activateRecoveredTenant: async (tenantId, signal) => {
+			signal.throwIfAborted();
+			const result = await options.client.db(globalDbName).collection(tenantCollection).updateOne({
+				tenantId: normalizeTenantId(tenantId),
+				...staleInitializingFilter()
+			}, {
+				$set: {
+					provisioningStatus: "active",
+					provisionedAt: /* @__PURE__ */ new Date()
+				},
+				$unset: { provisioningError: "" }
+			});
+			signal.throwIfAborted();
+			return result.matchedCount === 1;
+		},
 		filesystemRequired: options.filesystemRequired ?? (() => false),
 		filesystem: (tenantId) => options.client.db(`${appName}-${normalizeTenantId(tenantId)}-filesystem-db`)
 	};
@@ -968,7 +1046,9 @@ var planMigrations = async (registry, provider, options = {}) => {
 		databases,
 		hasPending: databases.some((database) => database.pending.length > 0 || database.running.length > 0 || database.failed.length > 0),
 		hasOffline: databases.some((database) => database.pending.some((migration) => migration.mode === "offline") || [...database.running, ...database.failed].some((id) => registry.migrationsById.get(id)?.mode === "offline")),
-		hasErrors: databases.some((database) => database.integrityErrors.length > 0 || database.running.length === 0 && database.failed.length === 0 && database.resourceDivergences.length > 0)
+		hasRollbackIncompatible: databases.some((database) => database.pending.some((migration) => migration.rollback === "incompatible") || [...database.running, ...database.failed].some((id) => registry.migrationsById.get(id)?.rollback === "incompatible")),
+		hasAppliedRollbackIncompatible: databases.some((database) => database.applied.some((id) => registry.migrationsById.get(id)?.rollback === "incompatible")),
+		hasErrors: databases.some((database) => database.integrityErrors.length > 0 || database.running.length === 0 && database.failed.length === 0 && database.resourceDivergences.some((divergence) => divergence.code !== "runtime_index_options_mismatch"))
 	};
 };
 //#endregion
@@ -1118,7 +1198,7 @@ var combineSignals = (...signals) => {
 };
 var assertPlanCanRun = (plan) => {
 	const retrying = plan.running.length > 0 || plan.failed.length > 0;
-	const errors = [...plan.integrityErrors, ...retrying ? [] : plan.resourceDivergences.map((divergence) => divergence.message)];
+	const errors = [...plan.integrityErrors, ...retrying ? [] : plan.resourceDivergences.filter((divergence) => divergence.code !== "runtime_index_options_mismatch").map((divergence) => divergence.message)];
 	if (errors.length > 0) throw new MigrationIntegrityError(`${plan.database}: ${errors.join("; ")}`);
 };
 var recordForMigration = (migration, lock, attempt, release) => ({
@@ -1276,8 +1356,15 @@ var applyMigration = async (registry, target, migration, lock, signal, release)
 };
 var sourcePredecessorsApplied = (registry, migration, applied) => registry.sources.find((source) => source.name === migration.source)?.migrations.filter((candidate) => candidate.scope === migration.scope && candidate.sourcePosition < migration.sourcePosition).every((candidate) => applied.has(candidate.qualifiedId)) ?? false;
 var runTarget = async (registry, target, lock, signal, options, earlierScopeDependencyApplied) => {
-	const plan = await planMigrationTarget(registry, target, { signal });
+	let plan = await planMigrationTarget(registry, target, { signal });
 	assertPlanCanRun(plan);
+	if (plan.resourceDivergences.some((divergence) => divergence.code === "runtime_index_options_mismatch")) {
+		const history = await readMigrationHistory(target.db);
+		const expectedResources = getExpectedResources(registry, target.scope, history);
+		await reconcileRuntimeIndexOptions(target.db, expectedResources, signal);
+		plan = await planMigrationTarget(registry, target, { signal });
+		assertPlanCanRun(plan);
+	}
 	const applied = new Set(plan.applied);
 	const migrationsToRun = registry.migrations.filter((migration) => migration.scope === target.scope && !applied.has(migration.qualifiedId));
 	for (const migration of migrationsToRun) {
@@ -1353,10 +1440,20 @@ var runMigrations = async (registry, provider, options = {}) => {
 				return false;
 			});
 		});
-		return await planMigrations(registry, provider, {
+		const plan = await planMigrations(registry, provider, {
 			tenantId: options.tenantId,
 			signal
 		});
+		let activatedRecoveredTenant = false;
+		if (!options.initializeTenant && provider.activateRecoveredTenant) for (const tenantId of tenantApplied.keys()) {
+			const tenantPlans = plan.databases.filter((database) => database.tenantId === tenantId);
+			if (!(tenantPlans.length > 0 && tenantPlans.every((database) => database.pending.length === 0 && database.running.length === 0 && database.failed.length === 0 && database.integrityErrors.length === 0 && database.resourceDivergences.length === 0))) continue;
+			if (await provider.activateRecoveredTenant(tenantId, signal)) activatedRecoveredTenant = true;
+		}
+		return activatedRecoveredTenant ? await planMigrations(registry, provider, {
+			tenantId: options.tenantId,
+			signal
+		}) : plan;
 	} finally {
 		await lock.release();
 	}
@@ -1377,7 +1474,7 @@ var assertMigrationsCurrent = async (registry, provider, options = {}) => {
 		if (database.running.length > 0) errors.push(`${database.database}: migration running`);
 		if (database.failed.length > 0) errors.push(`${database.database}: migration failed`);
 		errors.push(...database.integrityErrors.map((error) => `${database.database}: ${error}`));
-		errors.push(...database.resourceDivergences.map((divergence) => `${database.database}: ${divergence.message}`));
+		errors.push(...database.resourceDivergences.filter((divergence) => divergence.code !== "runtime_index_options_mismatch").map((divergence) => `${database.database}: ${divergence.message}`));
 	}
 	if (errors.length > 0) throw new MigrationIntegrityError(errors.join("; "));
 	return plan;
@@ -1561,6 +1658,6 @@ var testSingleMigration = async (options) => {
 	}
 };
 //#endregion
-export { MIGRATIONS_COLLECTION, MIGRATION_LOCKS_COLLECTION, MigrationIntegrityError, MigrationLockLostError, MigrationLockUnavailableError, acquireMigrationLock, assertMigrationsCurrent, canonicalChecksum, canonicalStringify, collectMigrationTargets, compileMigrationRegistry, computeMigrationIntegrity, createMigrationDatabaseProvider, createMigrationHelpers, createMigrationIntegrityPlugin, defineMigration, defineMigrationSource, defineMongoResources, diffMongoResources, filterMongoResources, getExpectedResources, getMigrationDatabaseName, initializeTenantMigrations, inspectMongoResources, mergeMongoResources, planMigrationTarget, planMigrations, readMigrationHistory, runMigrations, sha256, testMigrationRegistry, testSingleMigration };
+export { MIGRATIONS_COLLECTION, MIGRATION_LOCKS_COLLECTION, MigrationIntegrityError, MigrationLockLostError, MigrationLockUnavailableError, acquireMigrationLock, assertMigrationsCurrent, canonicalChecksum, canonicalStringify, collectMigrationTargets, compileMigrationRegistry, computeMigrationIntegrity, createMigrationDatabaseProvider, createMigrationHelpers, createMigrationIntegrityPlugin, defineMigration, defineMigrationSource, defineMongoResources, diffMongoResources, filterMongoResources, getExpectedResources, getMigrationDatabaseName, initializeTenantMigrations, inspectMongoResources, mergeMongoResources, planMigrationTarget, planMigrations, readMigrationHistory, reconcileRuntimeIndexOptions, runMigrations, sha256, testMigrationRegistry, testSingleMigration };
 
 //# sourceMappingURL=index.js.map