@hot-updater/plugin-core 0.36.7 → 1.0.0-rc.0

package/dist/releaseManagement.cjs

@@ -0,0 +1,231 @@
+require("./_virtual/_rolldown/runtime.cjs");
+const require_uuidv7 = require("./uuidv7.cjs");
+const require_releaseCatalogMutation = require("./releaseCatalogMutation.cjs");
+let _hot_updater_core = require("@hot-updater/core");
+//#region src/releaseManagement.ts
+const RELEASE_PAGE_SIZE = 1e3;
+var ReleaseManagementError = class extends Error {
+	name = "ReleaseManagementError";
+	constructor(code, message) {
+		super(message);
+		this.code = code;
+	}
+};
+const readReleaseScope = async (database, scopeKey) => {
+	const rows = [];
+	let afterReleaseId;
+	for (;;) {
+		const page = await database.models.releases.findManyByScope({
+			scopeKey,
+			...afterReleaseId === void 0 ? {} : { afterReleaseId },
+			consistency: "strong",
+			limit: RELEASE_PAGE_SIZE
+		});
+		rows.push(...page);
+		if (page.length < RELEASE_PAGE_SIZE) return rows;
+		const nextCursor = page.at(-1)?.id;
+		if (nextCursor === void 0 || nextCursor === afterReleaseId) throw new require_releaseCatalogMutation.ReleaseCatalogMutationError("INVALID_SCOPE", `Release paging did not advance for scope "${scopeKey}".`);
+		afterReleaseId = nextCursor;
+	}
+};
+const createForwardReleaseId = (rows, candidates, nowMs) => {
+	return require_uuidv7.createUUIDv7After([...candidates, rows.at(-1)?.id ?? null].filter((value) => value !== null && (0, _hot_updater_core.isUUIDv7)(value)).sort().at(-1) ?? null, nowMs);
+};
+const prepareTargetScope = async ({ channelName, database, fingerprintHash, platform, strategy }) => {
+	const channelKey = (0, _hot_updater_core.encodeChannelKey)(channelName);
+	const channel = (await database.models.channels.list({})).channels.find(({ name }) => name === channelName) ?? (await database.models.channels.insert({
+		row: {
+			id: `channel:${channelKey}`,
+			name: channelName
+		},
+		onConflict: "returnExisting"
+	})).row;
+	const scopeKey = strategy === "APP_VERSION" ? (0, _hot_updater_core.createReleaseCatalogScopeKey)({
+		channelKey,
+		platform,
+		strategy
+	}) : (0, _hot_updater_core.createReleaseCatalogScopeKey)({
+		channelKey,
+		fingerprintHash: fingerprintHash ?? "",
+		platform,
+		strategy
+	});
+	return { scope: {
+		channelId: channel.id,
+		channelName,
+		fingerprintHash,
+		platform,
+		scopeKey,
+		strategy
+	} };
+};
+const loadReleaseTarget = async (input) => {
+	const release = await input.database.models.releases.findById(input.releaseId);
+	if (release === null) throw new ReleaseManagementError("RELEASE_NOT_FOUND", `Release "${input.releaseId}" was not found.`);
+	if (input.expectedRevision !== void 0 && input.expectedRevision !== release.revision) throw new ReleaseManagementError("VERSION_CONFLICT", `Release "${release.id}" is revision ${release.revision}; expected ${input.expectedRevision}.`);
+	const catalog = await input.database.models.releaseCatalogs.findByScopeKey(release.scope_key);
+	if (catalog === null) throw new require_releaseCatalogMutation.ReleaseCatalogMutationError("INVALID_SCOPE", `Release "${release.id}" has no catalog projection.`);
+	return {
+		release,
+		scope: {
+			channelId: release.channel_id,
+			channelName: (0, _hot_updater_core.decodeChannelKey)(catalog.channel_key),
+			fingerprintHash: release.fingerprint_hash,
+			platform: release.platform,
+			scopeKey: release.scope_key,
+			strategy: release.strategy
+		}
+	};
+};
+const releasePolicyUpdate = (release, patch, updatedAtMs) => {
+	if (patch.fingerprintHash !== void 0 && patch.fingerprintHash !== release.fingerprint_hash) throw new ReleaseManagementError("SCOPE_MOVE_UNSUPPORTED", "Changing a fingerprint target requires an atomic Release scope move.");
+	return {
+		...patch.enabled === void 0 ? {} : { enabled: patch.enabled },
+		...patch.message === void 0 ? {} : { message: patch.message },
+		...patch.rolloutCohortCount === void 0 ? {} : { rollout_cohort_count: patch.rolloutCohortCount },
+		...patch.shouldForceUpdate === void 0 ? {} : { should_force_update: patch.shouldForceUpdate },
+		...patch.targetAppVersion === void 0 ? {} : { target_app_version: patch.targetAppVersion },
+		...patch.targetCohorts === void 0 ? {} : { target_cohorts: [...patch.targetCohorts] },
+		updated_at_ms: updatedAtMs
+	};
+};
+async function updateReleasePolicy(input) {
+	const { release, scope } = await loadReleaseTarget(input);
+	const updatedAtMs = input.updatedAtMs ?? Date.now();
+	return require_releaseCatalogMutation.commitReleaseCatalogMutation({
+		database: input.database,
+		mutation: {
+			id: release.id,
+			operation: "update",
+			update: releasePolicyUpdate(release, input.patch, updatedAtMs)
+		},
+		scope,
+		updatedAtMs
+	});
+}
+async function preflightReleasePolicy(input) {
+	const { release, scope } = await loadReleaseTarget(input);
+	const updatedAtMs = input.updatedAtMs ?? Date.now();
+	return require_releaseCatalogMutation.preflightReleaseCatalogMutation({
+		database: input.database,
+		mutation: {
+			id: release.id,
+			operation: "update",
+			update: releasePolicyUpdate(release, input.patch, updatedAtMs)
+		},
+		scope,
+		updatedAtMs
+	});
+}
+async function deleteRelease(input) {
+	const { release, scope } = await loadReleaseTarget(input);
+	if (release.enabled) throw new ReleaseManagementError("ENABLED_RELEASE", `Disable Release "${release.id}" before hard deletion.`);
+	return require_releaseCatalogMutation.commitReleaseCatalogMutation({
+		database: input.database,
+		mutation: {
+			id: release.id,
+			operation: "delete"
+		},
+		scope,
+		updatedAtMs: input.updatedAtMs
+	});
+}
+async function promoteRelease(input) {
+	const { release: source, scope: sourceScope } = await loadReleaseTarget(input);
+	if (source.kind !== "BUNDLE" || source.bundle_id === null) throw new ReleaseManagementError("TARGET_RELEASE_INVALID", "Only a Bundle Release can be promoted.");
+	const targetChannel = input.targetChannel.trim();
+	if (targetChannel.length === 0) throw new ReleaseManagementError("TARGET_RELEASE_INVALID", "Promotion requires a target channel.");
+	const { scope: targetScope } = await prepareTargetScope({
+		channelName: targetChannel,
+		database: input.database,
+		fingerprintHash: source.fingerprint_hash,
+		platform: source.platform,
+		strategy: source.strategy
+	});
+	if (targetScope.scopeKey === sourceScope.scopeKey) throw new ReleaseManagementError("TARGET_RELEASE_INVALID", "Source and target Release scopes are the same.");
+	const targetRows = await readReleaseScope(input.database, targetScope.scopeKey);
+	const updatedAtMs = input.updatedAtMs ?? Date.now();
+	const targetMutation = {
+		mutation: {
+			operation: "insert",
+			row: {
+				...source,
+				id: createForwardReleaseId(targetRows, [source.id, source.bundle_id], updatedAtMs),
+				revision: 1,
+				scope_key: targetScope.scopeKey,
+				channel_id: targetScope.channelId,
+				enabled: true,
+				rollout_cohort_count: 1e3,
+				target_cohorts: [],
+				operation: "PROMOTE",
+				source_release_id: source.id,
+				created_at_ms: updatedAtMs,
+				updated_at_ms: updatedAtMs
+			}
+		},
+		scope: targetScope,
+		updatedAtMs
+	};
+	const sourceMutation = input.action === "move" ? {
+		mutation: {
+			id: source.id,
+			operation: "update",
+			update: {
+				enabled: false,
+				updated_at_ms: updatedAtMs
+			}
+		},
+		scope: sourceScope,
+		updatedAtMs
+	} : null;
+	const results = await require_releaseCatalogMutation.commitReleaseCatalogMutations({
+		database: input.database,
+		mutations: sourceMutation === null ? [targetMutation] : [sourceMutation, targetMutation]
+	});
+	return {
+		source: sourceMutation === null ? null : results[0],
+		target: results.at(-1)
+	};
+}
+const prepareRollbackRelease = async (input) => {
+	const { release: source, scope } = await loadReleaseTarget(input);
+	if (!source.enabled) throw new ReleaseManagementError("TARGET_RELEASE_INVALID", "Rollback requires an enabled Release.");
+	const updatedAtMs = input.updatedAtMs ?? Date.now();
+	return {
+		mutation: {
+			id: source.id,
+			operation: "update",
+			update: {
+				enabled: false,
+				updated_at_ms: updatedAtMs
+			}
+		},
+		scope,
+		updatedAtMs
+	};
+};
+async function rollbackReleases(input) {
+	const mutations = await Promise.all(input.rollbacks.map((rollback) => prepareRollbackRelease({
+		...rollback,
+		database: input.database
+	})));
+	return require_releaseCatalogMutation.commitReleaseCatalogMutations({
+		database: input.database,
+		mutations
+	});
+}
+async function rollbackRelease(input) {
+	const [result] = await rollbackReleases({
+		database: input.database,
+		rollbacks: [input]
+	});
+	return result;
+}
+//#endregion
+exports.ReleaseManagementError = ReleaseManagementError;
+exports.deleteRelease = deleteRelease;
+exports.preflightReleasePolicy = preflightReleasePolicy;
+exports.promoteRelease = promoteRelease;
+exports.rollbackRelease = rollbackRelease;
+exports.rollbackReleases = rollbackReleases;
+exports.updateReleasePolicy = updateReleasePolicy;

package/dist/releaseManagement.d.cts

@@ -0,0 +1,48 @@
+import { BundleRepository } from "./types/databasePlugin.cjs";
+import { ReleaseCatalogMutationPreflight, ReleaseCatalogMutationResult } from "./releaseCatalogMutation.cjs";
+
+//#region src/releaseManagement.d.ts
+interface ReleasePolicyPatch {
+  readonly enabled?: boolean;
+  readonly fingerprintHash?: string;
+  readonly message?: string | null;
+  readonly rolloutCohortCount?: number;
+  readonly shouldForceUpdate?: boolean;
+  readonly targetAppVersion?: string;
+  readonly targetCohorts?: readonly string[];
+}
+interface ReleaseMutationTarget {
+  readonly database: BundleRepository;
+  readonly expectedRevision?: number;
+  readonly releaseId: string;
+  readonly updatedAtMs?: number;
+}
+declare class ReleaseManagementError extends Error {
+  readonly code: "ENABLED_RELEASE" | "RELEASE_NOT_FOUND" | "SCOPE_MOVE_UNSUPPORTED" | "TARGET_RELEASE_INVALID" | "VERSION_CONFLICT";
+  readonly name = "ReleaseManagementError";
+  constructor(code: "ENABLED_RELEASE" | "RELEASE_NOT_FOUND" | "SCOPE_MOVE_UNSUPPORTED" | "TARGET_RELEASE_INVALID" | "VERSION_CONFLICT", message: string);
+}
+declare function updateReleasePolicy(input: ReleaseMutationTarget & {
+  readonly patch: ReleasePolicyPatch;
+}): Promise<ReleaseCatalogMutationResult>;
+declare function preflightReleasePolicy(input: ReleaseMutationTarget & {
+  readonly patch: ReleasePolicyPatch;
+}): Promise<ReleaseCatalogMutationPreflight>;
+declare function deleteRelease(input: ReleaseMutationTarget): Promise<ReleaseCatalogMutationResult>;
+interface PromoteReleaseInput extends ReleaseMutationTarget {
+  readonly action?: "copy" | "move";
+  readonly targetChannel: string;
+}
+interface PromoteReleaseResult {
+  readonly source: ReleaseCatalogMutationResult | null;
+  readonly target: ReleaseCatalogMutationResult;
+}
+declare function promoteRelease(input: PromoteReleaseInput): Promise<PromoteReleaseResult>;
+type RollbackReleaseInput = ReleaseMutationTarget;
+declare function rollbackReleases(input: {
+  readonly database: BundleRepository;
+  readonly rollbacks: readonly Omit<RollbackReleaseInput, "database">[];
+}): Promise<readonly ReleaseCatalogMutationResult[]>;
+declare function rollbackRelease(input: RollbackReleaseInput): Promise<ReleaseCatalogMutationResult>;
+//#endregion
+export { PromoteReleaseInput, PromoteReleaseResult, ReleaseManagementError, ReleaseMutationTarget, ReleasePolicyPatch, RollbackReleaseInput, deleteRelease, preflightReleasePolicy, promoteRelease, rollbackRelease, rollbackReleases, updateReleasePolicy };

package/dist/releaseManagement.d.mts

@@ -0,0 +1,48 @@
+import { BundleRepository } from "./types/databasePlugin.mjs";
+import { ReleaseCatalogMutationPreflight, ReleaseCatalogMutationResult } from "./releaseCatalogMutation.mjs";
+
+//#region src/releaseManagement.d.ts
+interface ReleasePolicyPatch {
+  readonly enabled?: boolean;
+  readonly fingerprintHash?: string;
+  readonly message?: string | null;
+  readonly rolloutCohortCount?: number;
+  readonly shouldForceUpdate?: boolean;
+  readonly targetAppVersion?: string;
+  readonly targetCohorts?: readonly string[];
+}
+interface ReleaseMutationTarget {
+  readonly database: BundleRepository;
+  readonly expectedRevision?: number;
+  readonly releaseId: string;
+  readonly updatedAtMs?: number;
+}
+declare class ReleaseManagementError extends Error {
+  readonly code: "ENABLED_RELEASE" | "RELEASE_NOT_FOUND" | "SCOPE_MOVE_UNSUPPORTED" | "TARGET_RELEASE_INVALID" | "VERSION_CONFLICT";
+  readonly name = "ReleaseManagementError";
+  constructor(code: "ENABLED_RELEASE" | "RELEASE_NOT_FOUND" | "SCOPE_MOVE_UNSUPPORTED" | "TARGET_RELEASE_INVALID" | "VERSION_CONFLICT", message: string);
+}
+declare function updateReleasePolicy(input: ReleaseMutationTarget & {
+  readonly patch: ReleasePolicyPatch;
+}): Promise<ReleaseCatalogMutationResult>;
+declare function preflightReleasePolicy(input: ReleaseMutationTarget & {
+  readonly patch: ReleasePolicyPatch;
+}): Promise<ReleaseCatalogMutationPreflight>;
+declare function deleteRelease(input: ReleaseMutationTarget): Promise<ReleaseCatalogMutationResult>;
+interface PromoteReleaseInput extends ReleaseMutationTarget {
+  readonly action?: "copy" | "move";
+  readonly targetChannel: string;
+}
+interface PromoteReleaseResult {
+  readonly source: ReleaseCatalogMutationResult | null;
+  readonly target: ReleaseCatalogMutationResult;
+}
+declare function promoteRelease(input: PromoteReleaseInput): Promise<PromoteReleaseResult>;
+type RollbackReleaseInput = ReleaseMutationTarget;
+declare function rollbackReleases(input: {
+  readonly database: BundleRepository;
+  readonly rollbacks: readonly Omit<RollbackReleaseInput, "database">[];
+}): Promise<readonly ReleaseCatalogMutationResult[]>;
+declare function rollbackRelease(input: RollbackReleaseInput): Promise<ReleaseCatalogMutationResult>;
+//#endregion
+export { PromoteReleaseInput, PromoteReleaseResult, ReleaseManagementError, ReleaseMutationTarget, ReleasePolicyPatch, RollbackReleaseInput, deleteRelease, preflightReleasePolicy, promoteRelease, rollbackRelease, rollbackReleases, updateReleasePolicy };

package/dist/releaseManagement.mjs

@@ -0,0 +1,224 @@
+import { createUUIDv7After, isUUIDv7 as isUUIDv7$1 } from "./uuidv7.mjs";
+import { ReleaseCatalogMutationError, commitReleaseCatalogMutation, commitReleaseCatalogMutations, preflightReleaseCatalogMutation } from "./releaseCatalogMutation.mjs";
+import { createReleaseCatalogScopeKey, decodeChannelKey, encodeChannelKey } from "@hot-updater/core";
+//#region src/releaseManagement.ts
+const RELEASE_PAGE_SIZE = 1e3;
+var ReleaseManagementError = class extends Error {
+	name = "ReleaseManagementError";
+	constructor(code, message) {
+		super(message);
+		this.code = code;
+	}
+};
+const readReleaseScope = async (database, scopeKey) => {
+	const rows = [];
+	let afterReleaseId;
+	for (;;) {
+		const page = await database.models.releases.findManyByScope({
+			scopeKey,
+			...afterReleaseId === void 0 ? {} : { afterReleaseId },
+			consistency: "strong",
+			limit: RELEASE_PAGE_SIZE
+		});
+		rows.push(...page);
+		if (page.length < RELEASE_PAGE_SIZE) return rows;
+		const nextCursor = page.at(-1)?.id;
+		if (nextCursor === void 0 || nextCursor === afterReleaseId) throw new ReleaseCatalogMutationError("INVALID_SCOPE", `Release paging did not advance for scope "${scopeKey}".`);
+		afterReleaseId = nextCursor;
+	}
+};
+const createForwardReleaseId = (rows, candidates, nowMs) => {
+	return createUUIDv7After([...candidates, rows.at(-1)?.id ?? null].filter((value) => value !== null && isUUIDv7$1(value)).sort().at(-1) ?? null, nowMs);
+};
+const prepareTargetScope = async ({ channelName, database, fingerprintHash, platform, strategy }) => {
+	const channelKey = encodeChannelKey(channelName);
+	const channel = (await database.models.channels.list({})).channels.find(({ name }) => name === channelName) ?? (await database.models.channels.insert({
+		row: {
+			id: `channel:${channelKey}`,
+			name: channelName
+		},
+		onConflict: "returnExisting"
+	})).row;
+	const scopeKey = strategy === "APP_VERSION" ? createReleaseCatalogScopeKey({
+		channelKey,
+		platform,
+		strategy
+	}) : createReleaseCatalogScopeKey({
+		channelKey,
+		fingerprintHash: fingerprintHash ?? "",
+		platform,
+		strategy
+	});
+	return { scope: {
+		channelId: channel.id,
+		channelName,
+		fingerprintHash,
+		platform,
+		scopeKey,
+		strategy
+	} };
+};
+const loadReleaseTarget = async (input) => {
+	const release = await input.database.models.releases.findById(input.releaseId);
+	if (release === null) throw new ReleaseManagementError("RELEASE_NOT_FOUND", `Release "${input.releaseId}" was not found.`);
+	if (input.expectedRevision !== void 0 && input.expectedRevision !== release.revision) throw new ReleaseManagementError("VERSION_CONFLICT", `Release "${release.id}" is revision ${release.revision}; expected ${input.expectedRevision}.`);
+	const catalog = await input.database.models.releaseCatalogs.findByScopeKey(release.scope_key);
+	if (catalog === null) throw new ReleaseCatalogMutationError("INVALID_SCOPE", `Release "${release.id}" has no catalog projection.`);
+	return {
+		release,
+		scope: {
+			channelId: release.channel_id,
+			channelName: decodeChannelKey(catalog.channel_key),
+			fingerprintHash: release.fingerprint_hash,
+			platform: release.platform,
+			scopeKey: release.scope_key,
+			strategy: release.strategy
+		}
+	};
+};
+const releasePolicyUpdate = (release, patch, updatedAtMs) => {
+	if (patch.fingerprintHash !== void 0 && patch.fingerprintHash !== release.fingerprint_hash) throw new ReleaseManagementError("SCOPE_MOVE_UNSUPPORTED", "Changing a fingerprint target requires an atomic Release scope move.");
+	return {
+		...patch.enabled === void 0 ? {} : { enabled: patch.enabled },
+		...patch.message === void 0 ? {} : { message: patch.message },
+		...patch.rolloutCohortCount === void 0 ? {} : { rollout_cohort_count: patch.rolloutCohortCount },
+		...patch.shouldForceUpdate === void 0 ? {} : { should_force_update: patch.shouldForceUpdate },
+		...patch.targetAppVersion === void 0 ? {} : { target_app_version: patch.targetAppVersion },
+		...patch.targetCohorts === void 0 ? {} : { target_cohorts: [...patch.targetCohorts] },
+		updated_at_ms: updatedAtMs
+	};
+};
+async function updateReleasePolicy(input) {
+	const { release, scope } = await loadReleaseTarget(input);
+	const updatedAtMs = input.updatedAtMs ?? Date.now();
+	return commitReleaseCatalogMutation({
+		database: input.database,
+		mutation: {
+			id: release.id,
+			operation: "update",
+			update: releasePolicyUpdate(release, input.patch, updatedAtMs)
+		},
+		scope,
+		updatedAtMs
+	});
+}
+async function preflightReleasePolicy(input) {
+	const { release, scope } = await loadReleaseTarget(input);
+	const updatedAtMs = input.updatedAtMs ?? Date.now();
+	return preflightReleaseCatalogMutation({
+		database: input.database,
+		mutation: {
+			id: release.id,
+			operation: "update",
+			update: releasePolicyUpdate(release, input.patch, updatedAtMs)
+		},
+		scope,
+		updatedAtMs
+	});
+}
+async function deleteRelease(input) {
+	const { release, scope } = await loadReleaseTarget(input);
+	if (release.enabled) throw new ReleaseManagementError("ENABLED_RELEASE", `Disable Release "${release.id}" before hard deletion.`);
+	return commitReleaseCatalogMutation({
+		database: input.database,
+		mutation: {
+			id: release.id,
+			operation: "delete"
+		},
+		scope,
+		updatedAtMs: input.updatedAtMs
+	});
+}
+async function promoteRelease(input) {
+	const { release: source, scope: sourceScope } = await loadReleaseTarget(input);
+	if (source.kind !== "BUNDLE" || source.bundle_id === null) throw new ReleaseManagementError("TARGET_RELEASE_INVALID", "Only a Bundle Release can be promoted.");
+	const targetChannel = input.targetChannel.trim();
+	if (targetChannel.length === 0) throw new ReleaseManagementError("TARGET_RELEASE_INVALID", "Promotion requires a target channel.");
+	const { scope: targetScope } = await prepareTargetScope({
+		channelName: targetChannel,
+		database: input.database,
+		fingerprintHash: source.fingerprint_hash,
+		platform: source.platform,
+		strategy: source.strategy
+	});
+	if (targetScope.scopeKey === sourceScope.scopeKey) throw new ReleaseManagementError("TARGET_RELEASE_INVALID", "Source and target Release scopes are the same.");
+	const targetRows = await readReleaseScope(input.database, targetScope.scopeKey);
+	const updatedAtMs = input.updatedAtMs ?? Date.now();
+	const targetMutation = {
+		mutation: {
+			operation: "insert",
+			row: {
+				...source,
+				id: createForwardReleaseId(targetRows, [source.id, source.bundle_id], updatedAtMs),
+				revision: 1,
+				scope_key: targetScope.scopeKey,
+				channel_id: targetScope.channelId,
+				enabled: true,
+				rollout_cohort_count: 1e3,
+				target_cohorts: [],
+				operation: "PROMOTE",
+				source_release_id: source.id,
+				created_at_ms: updatedAtMs,
+				updated_at_ms: updatedAtMs
+			}
+		},
+		scope: targetScope,
+		updatedAtMs
+	};
+	const sourceMutation = input.action === "move" ? {
+		mutation: {
+			id: source.id,
+			operation: "update",
+			update: {
+				enabled: false,
+				updated_at_ms: updatedAtMs
+			}
+		},
+		scope: sourceScope,
+		updatedAtMs
+	} : null;
+	const results = await commitReleaseCatalogMutations({
+		database: input.database,
+		mutations: sourceMutation === null ? [targetMutation] : [sourceMutation, targetMutation]
+	});
+	return {
+		source: sourceMutation === null ? null : results[0],
+		target: results.at(-1)
+	};
+}
+const prepareRollbackRelease = async (input) => {
+	const { release: source, scope } = await loadReleaseTarget(input);
+	if (!source.enabled) throw new ReleaseManagementError("TARGET_RELEASE_INVALID", "Rollback requires an enabled Release.");
+	const updatedAtMs = input.updatedAtMs ?? Date.now();
+	return {
+		mutation: {
+			id: source.id,
+			operation: "update",
+			update: {
+				enabled: false,
+				updated_at_ms: updatedAtMs
+			}
+		},
+		scope,
+		updatedAtMs
+	};
+};
+async function rollbackReleases(input) {
+	const mutations = await Promise.all(input.rollbacks.map((rollback) => prepareRollbackRelease({
+		...rollback,
+		database: input.database
+	})));
+	return commitReleaseCatalogMutations({
+		database: input.database,
+		mutations
+	});
+}
+async function rollbackRelease(input) {
+	const [result] = await rollbackReleases({
+		database: input.database,
+		rollbacks: [input]
+	});
+	return result;
+}
+//#endregion
+export { ReleaseManagementError, deleteRelease, preflightReleasePolicy, promoteRelease, rollbackRelease, rollbackReleases, updateReleasePolicy };