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

package/dist/handlerBundleRoutes.mjs

@@ -0,0 +1,155 @@
+import { HandlerBadRequestError } from "./handlerErrors.mjs";
+import { decodeMaybe, isPlatform, parsePositiveIntegerSearchParam, parseStringArraySearchParam, requireRouteParam } from "./handlerParameters.mjs";
+//#region src/handlerBundleRoutes.ts
+const BUNDLE_LIST_BOUNDS = {
+	defaultValue: 50,
+	maxValue: 100
+};
+const isChannelText = (value) => {
+	if (typeof value !== "string" || value.length === 0) return false;
+	let codePoints = 0;
+	for (const _codePoint of value) {
+		codePoints += 1;
+		if (codePoints > 255) return false;
+	}
+	return true;
+};
+const requireChannelInsertInput = (value) => {
+	if (!value || typeof value !== "object" || Array.isArray(value) || !("row" in value) || !value.row || typeof value.row !== "object" || Array.isArray(value.row) || !("id" in value.row) || !isChannelText(value.row.id) || !("name" in value.row) || !isChannelText(value.row.name) || !("onConflict" in value) || value.onConflict !== "returnExisting") throw new HandlerBadRequestError("Invalid Channel insert payload");
+	return {
+		row: {
+			id: value.row.id,
+			name: value.row.name
+		},
+		onConflict: value.onConflict
+	};
+};
+const requireBundlePatchPayload = (payload, bundleId) => {
+	if (!payload || typeof payload !== "object" || Array.isArray(payload)) throw new HandlerBadRequestError("Invalid bundle payload");
+	const bundlePatch = payload;
+	if (bundlePatch.id !== void 0 && bundlePatch.id !== bundleId) throw new HandlerBadRequestError("Bundle id mismatch");
+	const { id: _ignoredId, ...rest } = bundlePatch;
+	return rest;
+};
+const createBundleRouteHandlers = () => ({
+	getBundle: async (params, _request, api) => {
+		const bundle = await api.getBundleById(requireRouteParam(params, "id"));
+		if (!bundle) return new Response(JSON.stringify({ error: "Bundle not found" }), {
+			status: 404,
+			headers: { "Content-Type": "application/json" }
+		});
+		return new Response(JSON.stringify(bundle), {
+			status: 200,
+			headers: { "Content-Type": "application/json" }
+		});
+	},
+	getBundles: async (_params, request, api) => {
+		const url = new URL(request.url);
+		const platform = url.searchParams.get("platform");
+		const limit = parsePositiveIntegerSearchParam(url, "limit", BUNDLE_LIST_BOUNDS);
+		const pageParam = url.searchParams.get("page");
+		const offset = url.searchParams.get("offset");
+		const after = url.searchParams.get("after") ?? void 0;
+		const before = url.searchParams.get("before") ?? void 0;
+		const orderDirection = url.searchParams.get("orderDirection");
+		const idEq = url.searchParams.get("idEq") ?? void 0;
+		const idGt = url.searchParams.get("idGt") ?? void 0;
+		const idGte = url.searchParams.get("idGte") ?? void 0;
+		const idLt = url.searchParams.get("idLt") ?? void 0;
+		const idLte = url.searchParams.get("idLte") ?? void 0;
+		const idIn = parseStringArraySearchParam(url, "idIn");
+		const page = pageParam === null ? void 0 : Number.isSafeInteger(Number(pageParam)) && Number(pageParam) > 0 && Number.isSafeInteger((Number(pageParam) - 1) * limit) ? Number(pageParam) : null;
+		if (offset !== null) throw new HandlerBadRequestError("The 'offset' query parameter has been removed. Use 'after' or 'before' cursor pagination instead.");
+		if (page === null) throw new HandlerBadRequestError("The 'page' query parameter must be a positive integer.");
+		if (after !== void 0 && before !== void 0) throw new HandlerBadRequestError("The 'after' and 'before' query parameters cannot be combined.");
+		if (page !== void 0 && (after !== void 0 || before !== void 0)) throw new HandlerBadRequestError("The 'page' query parameter cannot be combined with 'after' or 'before'.");
+		if (platform !== null && !isPlatform(platform)) throw new HandlerBadRequestError(`Invalid platform: ${platform}. Expected 'ios' or 'android'.`);
+		if (orderDirection !== null && orderDirection !== "asc" && orderDirection !== "desc") throw new HandlerBadRequestError("The 'orderDirection' query parameter must be 'asc' or 'desc'.");
+		const pagination = page === void 0 ? {
+			cursor: after !== void 0 ? { after } : before !== void 0 ? { before } : void 0,
+			page: void 0
+		} : {
+			cursor: void 0,
+			page
+		};
+		const result = await api.getBundles({
+			where: {
+				...platform && { platform },
+				...idEq || idGt || idGte || idLt || idLte || idIn?.length ? { id: {
+					...idEq && { eq: idEq },
+					...idGt && { gt: idGt },
+					...idGte && { gte: idGte },
+					...idLt && { lt: idLt },
+					...idLte && { lte: idLte },
+					...idIn?.length && { in: idIn }
+				} } : {}
+			},
+			limit,
+			...pagination,
+			...orderDirection && { orderBy: {
+				field: "id",
+				direction: orderDirection
+			} }
+		});
+		return new Response(JSON.stringify(result), {
+			status: 200,
+			headers: { "Content-Type": "application/json" }
+		});
+	},
+	createBundles: async (_params, request, api) => {
+		const body = await request.json();
+		const bundles = Array.isArray(body) ? body : [body];
+		if (api.insertBundles) await api.insertBundles(bundles);
+		else {
+			if (bundles.length > 1) throw new HandlerBadRequestError("This server does not support atomic bundle batches");
+			const bundle = bundles[0];
+			if (bundle !== void 0) await api.insertBundle(bundle);
+		}
+		return new Response(JSON.stringify({ success: true }), {
+			status: 201,
+			headers: { "Content-Type": "application/json" }
+		});
+	},
+	updateBundle: async (params, request, api) => {
+		const bundleId = requireRouteParam(params, "id");
+		const body = await request.json();
+		const payload = Array.isArray(body) ? body[0] : body;
+		await api.updateBundleById(bundleId, requireBundlePatchPayload(payload, bundleId));
+		return new Response(JSON.stringify({ success: true }), {
+			status: 200,
+			headers: { "Content-Type": "application/json" }
+		});
+	},
+	deleteBundle: async (params, _request, api) => {
+		await api.deleteBundleById(requireRouteParam(params, "id"));
+		return new Response(JSON.stringify({ success: true }), {
+			status: 200,
+			headers: { "Content-Type": "application/json" }
+		});
+	},
+	getChannels: async (_params, _request, api) => {
+		const response = { data: { channels: await api.getChannels() } };
+		return new Response(JSON.stringify(response), {
+			status: 200,
+			headers: { "Content-Type": "application/json" }
+		});
+	},
+	createChannel: async (_params, request, api) => {
+		const result = await api.insertChannel(requireChannelInsertInput(await request.json()));
+		return new Response(JSON.stringify({ data: result }), {
+			status: result.inserted ? 201 : 200,
+			headers: { "Content-Type": "application/json" }
+		});
+	},
+	deleteChannel: async (params, _request, api) => {
+		const result = await api.deleteChannel({ id: decodeMaybe(requireRouteParam(params, "id")) ?? "" });
+		if (result.deleted) return new Response(null, { status: 204 });
+		const status = result.reason === "not_found" ? 404 : 409;
+		return new Response(JSON.stringify({ data: result }), {
+			status,
+			headers: { "Content-Type": "application/json" }
+		});
+	}
+});
+//#endregion
+export { createBundleRouteHandlers };

package/dist/handlerErrors.cjs

@@ -0,0 +1,9 @@
+//#region src/handlerErrors.ts
+var HandlerBadRequestError = class extends Error {
+	name = "HandlerBadRequestError";
+	constructor(message) {
+		super(message);
+	}
+};
+//#endregion
+exports.HandlerBadRequestError = HandlerBadRequestError;

package/dist/handlerErrors.mjs

@@ -0,0 +1,9 @@
+//#region src/handlerErrors.ts
+var HandlerBadRequestError = class extends Error {
+	name = "HandlerBadRequestError";
+	constructor(message) {
+		super(message);
+	}
+};
+//#endregion
+export { HandlerBadRequestError };

package/dist/handlerParameters.cjs

@@ -0,0 +1,39 @@
+const require_handlerErrors = require("./handlerErrors.cjs");
+//#region src/handlerParameters.ts
+const decodeMaybe = (value) => {
+	if (value === void 0) return void 0;
+	try {
+		return decodeURIComponent(value);
+	} catch {
+		return value;
+	}
+};
+const isPlatform = (value) => value === "ios" || value === "android";
+const requireRouteParam = (params, key) => {
+	const value = params[key];
+	if (!value) throw new require_handlerErrors.HandlerBadRequestError(`Missing route parameter: ${key}`);
+	return value;
+};
+const requirePlatformParam = (params) => {
+	const platform = requireRouteParam(params, "platform");
+	if (!isPlatform(platform)) throw new require_handlerErrors.HandlerBadRequestError(`Invalid platform: ${platform}. Expected 'ios' or 'android'.`);
+	return platform;
+};
+const parseStringArraySearchParam = (url, key) => {
+	const values = url.searchParams.getAll(key);
+	return values.length > 0 ? values : void 0;
+};
+const parsePositiveIntegerSearchParam = (url, key, bounds) => {
+	const value = url.searchParams.get(key);
+	if (value === null) return bounds.defaultValue;
+	const parsed = Number(value);
+	if (!Number.isInteger(parsed) || parsed < 1 || parsed > bounds.maxValue) throw new require_handlerErrors.HandlerBadRequestError(`The '${key}' query parameter must be a positive integer between 1 and ${bounds.maxValue}.`);
+	return parsed;
+};
+//#endregion
+exports.decodeMaybe = decodeMaybe;
+exports.isPlatform = isPlatform;
+exports.parsePositiveIntegerSearchParam = parsePositiveIntegerSearchParam;
+exports.parseStringArraySearchParam = parseStringArraySearchParam;
+exports.requirePlatformParam = requirePlatformParam;
+exports.requireRouteParam = requireRouteParam;

package/dist/handlerParameters.mjs

@@ -0,0 +1,34 @@
+import { HandlerBadRequestError } from "./handlerErrors.mjs";
+//#region src/handlerParameters.ts
+const decodeMaybe = (value) => {
+	if (value === void 0) return void 0;
+	try {
+		return decodeURIComponent(value);
+	} catch {
+		return value;
+	}
+};
+const isPlatform = (value) => value === "ios" || value === "android";
+const requireRouteParam = (params, key) => {
+	const value = params[key];
+	if (!value) throw new HandlerBadRequestError(`Missing route parameter: ${key}`);
+	return value;
+};
+const requirePlatformParam = (params) => {
+	const platform = requireRouteParam(params, "platform");
+	if (!isPlatform(platform)) throw new HandlerBadRequestError(`Invalid platform: ${platform}. Expected 'ios' or 'android'.`);
+	return platform;
+};
+const parseStringArraySearchParam = (url, key) => {
+	const values = url.searchParams.getAll(key);
+	return values.length > 0 ? values : void 0;
+};
+const parsePositiveIntegerSearchParam = (url, key, bounds) => {
+	const value = url.searchParams.get(key);
+	if (value === null) return bounds.defaultValue;
+	const parsed = Number(value);
+	if (!Number.isInteger(parsed) || parsed < 1 || parsed > bounds.maxValue) throw new HandlerBadRequestError(`The '${key}' query parameter must be a positive integer between 1 and ${bounds.maxValue}.`);
+	return parsed;
+};
+//#endregion
+export { decodeMaybe, isPlatform, parsePositiveIntegerSearchParam, parseStringArraySearchParam, requirePlatformParam, requireRouteParam };

package/dist/handlerReleaseCatalogRoutes.cjs

@@ -0,0 +1,111 @@
+require("./_virtual/_rolldown/runtime.cjs");
+const require_handlerParameters = require("./handlerParameters.cjs");
+let _hot_updater_plugin_core = require("@hot-updater/plugin-core");
+//#region src/handlerReleaseCatalogRoutes.ts
+const CATALOG_CONTENT_TYPE = "application/vnd.hot-updater.release-catalog+json; version=1";
+const ORIGIN_CACHE_TTL_MS = 5e3;
+const ORIGIN_CACHE_MAX_ENTRIES = 128;
+const privateNotFound = () => Response.json({ error: "Not found" }, {
+	status: 404,
+	headers: { "cache-control": "private, no-store" }
+});
+const responseHash = async (body) => {
+	const digest = await crypto.subtle.digest("SHA-256", new TextEncoder().encode(body));
+	return [...new Uint8Array(digest)].map((byte) => byte.toString(16).padStart(2, "0")).join("");
+};
+const catalogResponse = async (catalog, request, clientAccessHeaderName) => {
+	if (catalog === null) return privateNotFound();
+	const body = JSON.stringify(catalog);
+	const etag = `"sha256:${await responseHash(body)}"`;
+	const headers = {
+		"cache-control": "public, max-age=0, s-maxage=5",
+		"content-type": CATALOG_CONTENT_TYPE,
+		etag,
+		vary: `Accept-Encoding, ${clientAccessHeaderName}`
+	};
+	if (request.headers.get("if-none-match") === etag) return new Response(null, {
+		headers,
+		status: 304
+	});
+	return new Response(body, {
+		headers,
+		status: 200
+	});
+};
+const createReleaseCatalogRouteHandlers = (clientAccessHeaderName = "x-api-key") => {
+	const cache = /* @__PURE__ */ new Map();
+	const inFlight = /* @__PURE__ */ new Map();
+	const loadCatalog = async (key, load) => {
+		const cached = cache.get(key);
+		if (cached !== void 0 && cached.expiresAt > Date.now()) {
+			cache.delete(key);
+			cache.set(key, cached);
+			return cached.catalog;
+		}
+		if (cached !== void 0) cache.delete(key);
+		const pending = inFlight.get(key);
+		if (pending !== void 0) return pending;
+		const next = load().then((catalog) => {
+			if (catalog !== null) {
+				cache.set(key, {
+					catalog,
+					expiresAt: Date.now() + ORIGIN_CACHE_TTL_MS
+				});
+				while (cache.size > ORIGIN_CACHE_MAX_ENTRIES) {
+					const oldestKey = cache.keys().next().value;
+					if (oldestKey === void 0) break;
+					cache.delete(oldestKey);
+				}
+			}
+			return catalog;
+		});
+		inFlight.set(key, next);
+		try {
+			return await next;
+		} finally {
+			inFlight.delete(key);
+		}
+	};
+	return {
+		appVersionReleaseCatalog: async (params, request, api) => {
+			if (api.getReleaseCatalog === void 0) return privateNotFound();
+			const rawAppVersion = require_handlerParameters.requireRouteParam(params, "appVersion");
+			const appVersion = (0, _hot_updater_plugin_core.canonicalizeAppVersion)(rawAppVersion);
+			if (appVersion === null || appVersion !== rawAppVersion) return Response.json({ error: "Invalid app version" }, {
+				status: 400,
+				headers: { "cache-control": "private, no-store" }
+			});
+			const input = {
+				appVersion,
+				channelKey: require_handlerParameters.requireRouteParam(params, "channelKey"),
+				platform: require_handlerParameters.requirePlatformParam(params),
+				strategy: "APP_VERSION"
+			};
+			return catalogResponse(await loadCatalog(`app-version:${JSON.stringify(input)}`, () => api.getReleaseCatalog(input)), request, clientAccessHeaderName);
+		},
+		fingerprintReleaseCatalog: async (params, request, api) => {
+			if (api.getReleaseCatalog === void 0) return privateNotFound();
+			const input = {
+				channelKey: require_handlerParameters.requireRouteParam(params, "channelKey"),
+				fingerprintHash: require_handlerParameters.requireRouteParam(params, "fingerprintHash"),
+				platform: require_handlerParameters.requirePlatformParam(params),
+				strategy: "FINGERPRINT"
+			};
+			return catalogResponse(await loadCatalog(`fingerprint:${JSON.stringify(input)}`, () => api.getReleaseCatalog(input)), request, clientAccessHeaderName);
+		},
+		artifact: async (params, _request, api) => {
+			if (api.getArtifactInfo === void 0) return privateNotFound();
+			const info = await api.getArtifactInfo(require_handlerParameters.requireRouteParam(params, "targetBundleId"), require_handlerParameters.requireRouteParam(params, "currentBundleId"));
+			if (info === null) return privateNotFound();
+			return new Response(JSON.stringify(info), {
+				status: 200,
+				headers: {
+					"cache-control": "private, no-store",
+					"content-type": "application/json"
+				}
+			});
+		}
+	};
+};
+//#endregion
+exports.createReleaseCatalogRouteHandlers = createReleaseCatalogRouteHandlers;

package/dist/handlerReleaseCatalogRoutes.mjs

@@ -0,0 +1,110 @@
+import { requirePlatformParam, requireRouteParam } from "./handlerParameters.mjs";
+import { canonicalizeAppVersion } from "@hot-updater/plugin-core";
+//#region src/handlerReleaseCatalogRoutes.ts
+const CATALOG_CONTENT_TYPE = "application/vnd.hot-updater.release-catalog+json; version=1";
+const ORIGIN_CACHE_TTL_MS = 5e3;
+const ORIGIN_CACHE_MAX_ENTRIES = 128;
+const privateNotFound = () => Response.json({ error: "Not found" }, {
+	status: 404,
+	headers: { "cache-control": "private, no-store" }
+});
+const responseHash = async (body) => {
+	const digest = await crypto.subtle.digest("SHA-256", new TextEncoder().encode(body));
+	return [...new Uint8Array(digest)].map((byte) => byte.toString(16).padStart(2, "0")).join("");
+};
+const catalogResponse = async (catalog, request, clientAccessHeaderName) => {
+	if (catalog === null) return privateNotFound();
+	const body = JSON.stringify(catalog);
+	const etag = `"sha256:${await responseHash(body)}"`;
+	const headers = {
+		"cache-control": "public, max-age=0, s-maxage=5",
+		"content-type": CATALOG_CONTENT_TYPE,
+		etag,
+		vary: `Accept-Encoding, ${clientAccessHeaderName}`
+	};
+	if (request.headers.get("if-none-match") === etag) return new Response(null, {
+		headers,
+		status: 304
+	});
+	return new Response(body, {
+		headers,
+		status: 200
+	});
+};
+const createReleaseCatalogRouteHandlers = (clientAccessHeaderName = "x-api-key") => {
+	const cache = /* @__PURE__ */ new Map();
+	const inFlight = /* @__PURE__ */ new Map();
+	const loadCatalog = async (key, load) => {
+		const cached = cache.get(key);
+		if (cached !== void 0 && cached.expiresAt > Date.now()) {
+			cache.delete(key);
+			cache.set(key, cached);
+			return cached.catalog;
+		}
+		if (cached !== void 0) cache.delete(key);
+		const pending = inFlight.get(key);
+		if (pending !== void 0) return pending;
+		const next = load().then((catalog) => {
+			if (catalog !== null) {
+				cache.set(key, {
+					catalog,
+					expiresAt: Date.now() + ORIGIN_CACHE_TTL_MS
+				});
+				while (cache.size > ORIGIN_CACHE_MAX_ENTRIES) {
+					const oldestKey = cache.keys().next().value;
+					if (oldestKey === void 0) break;
+					cache.delete(oldestKey);
+				}
+			}
+			return catalog;
+		});
+		inFlight.set(key, next);
+		try {
+			return await next;
+		} finally {
+			inFlight.delete(key);
+		}
+	};
+	return {
+		appVersionReleaseCatalog: async (params, request, api) => {
+			if (api.getReleaseCatalog === void 0) return privateNotFound();
+			const rawAppVersion = requireRouteParam(params, "appVersion");
+			const appVersion = canonicalizeAppVersion(rawAppVersion);
+			if (appVersion === null || appVersion !== rawAppVersion) return Response.json({ error: "Invalid app version" }, {
+				status: 400,
+				headers: { "cache-control": "private, no-store" }
+			});
+			const input = {
+				appVersion,
+				channelKey: requireRouteParam(params, "channelKey"),
+				platform: requirePlatformParam(params),
+				strategy: "APP_VERSION"
+			};
+			return catalogResponse(await loadCatalog(`app-version:${JSON.stringify(input)}`, () => api.getReleaseCatalog(input)), request, clientAccessHeaderName);
+		},
+		fingerprintReleaseCatalog: async (params, request, api) => {
+			if (api.getReleaseCatalog === void 0) return privateNotFound();
+			const input = {
+				channelKey: requireRouteParam(params, "channelKey"),
+				fingerprintHash: requireRouteParam(params, "fingerprintHash"),
+				platform: requirePlatformParam(params),
+				strategy: "FINGERPRINT"
+			};
+			return catalogResponse(await loadCatalog(`fingerprint:${JSON.stringify(input)}`, () => api.getReleaseCatalog(input)), request, clientAccessHeaderName);
+		},
+		artifact: async (params, _request, api) => {
+			if (api.getArtifactInfo === void 0) return privateNotFound();
+			const info = await api.getArtifactInfo(requireRouteParam(params, "targetBundleId"), requireRouteParam(params, "currentBundleId"));
+			if (info === null) return privateNotFound();
+			return new Response(JSON.stringify(info), {
+				status: 200,
+				headers: {
+					"cache-control": "private, no-store",
+					"content-type": "application/json"
+				}
+			});
+		}
+	};
+};
+//#endregion
+export { createReleaseCatalogRouteHandlers };

package/dist/handlerReleaseManagementRoutes.cjs

@@ -0,0 +1,125 @@
+require("./_virtual/_rolldown/runtime.cjs");
+const require_handlerErrors = require("./handlerErrors.cjs");
+const require_handlerParameters = require("./handlerParameters.cjs");
+let _hot_updater_plugin_core = require("@hot-updater/plugin-core");
+//#region src/handlerReleaseManagementRoutes.ts
+const unavailable = () => Response.json({ error: "Not found" }, { status: 404 });
+const isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+const parseRevision = (value) => {
+	if (value === void 0 || value === null || value === "") return void 0;
+	const revision = typeof value === "number" ? value : Number(value);
+	if (!Number.isSafeInteger(revision) || revision < 1) throw new require_handlerErrors.HandlerBadRequestError("Invalid expected Release revision");
+	return revision;
+};
+const parsePolicyInput = async (request) => {
+	const body = await request.json();
+	if (!isRecord(body) || !isRecord(body.patch)) throw new require_handlerErrors.HandlerBadRequestError("Invalid Release policy mutation");
+	return {
+		expectedRevision: parseRevision(body.expectedRevision),
+		patch: body.patch
+	};
+};
+const mutationResponse = async (operation) => {
+	try {
+		return Response.json({ data: await operation() });
+	} catch (error) {
+		if (error instanceof _hot_updater_plugin_core.ReleaseManagementError || error instanceof _hot_updater_plugin_core.ReleaseCatalogMutationError) {
+			const status = error.code === "RELEASE_NOT_FOUND" ? 404 : error.code === "VERSION_CONFLICT" ? 409 : 400;
+			return Response.json({
+				code: error.code,
+				error: error.message
+			}, { status });
+		}
+		throw error;
+	}
+};
+const createReleaseManagementRouteHandlers = () => ({
+	getRelease: async (params, _request, api) => {
+		if (api.getReleaseById === void 0) return unavailable();
+		const row = await api.getReleaseById(require_handlerParameters.requireRouteParam(params, "id"));
+		return row === null ? unavailable() : Response.json({ data: row }, { status: 200 });
+	},
+	getReleases: async (_params, request, api) => {
+		const url = new URL(request.url);
+		const scopeKey = url.searchParams.get("scopeKey");
+		const limit = Number(url.searchParams.get("limit") ?? "100");
+		if (!Number.isSafeInteger(limit) || limit <= 0 || limit > 1e3) throw new require_handlerErrors.HandlerBadRequestError("Invalid Release scope query");
+		if (scopeKey !== null) {
+			if (scopeKey.length === 0 || api.getReleasesByScope === void 0) throw new require_handlerErrors.HandlerBadRequestError("Invalid Release scope query");
+			const afterReleaseId = url.searchParams.get("afterReleaseId") ?? void 0;
+			return Response.json({ data: await api.getReleasesByScope({
+				...afterReleaseId === void 0 ? {} : { afterReleaseId },
+				limit,
+				scopeKey
+			}) });
+		}
+		if (api.getReleases === void 0) return unavailable();
+		const enabledValue = url.searchParams.get("enabled");
+		const enabled = enabledValue === null ? void 0 : enabledValue === "true" ? true : enabledValue === "false" ? false : null;
+		const platformValue = url.searchParams.get("platform");
+		const platform = platformValue === null ? void 0 : platformValue === "ios" || platformValue === "android" ? platformValue : null;
+		if (enabled === null || platform === null) throw new require_handlerErrors.HandlerBadRequestError("Invalid Release list filter");
+		return Response.json({ data: await api.getReleases({
+			afterReleaseId: url.searchParams.get("afterReleaseId") ?? void 0,
+			beforeReleaseId: url.searchParams.get("beforeReleaseId") ?? void 0,
+			bundleId: url.searchParams.get("bundleId") ?? void 0,
+			channelId: url.searchParams.get("channelId") ?? void 0,
+			enabled,
+			limit,
+			platform,
+			targetAppVersion: url.searchParams.get("targetAppVersion") ?? void 0
+		}) });
+	},
+	getReleaseCatalogRow: async (params, _request, api) => {
+		if (api.getReleaseCatalogByScopeKey === void 0) return unavailable();
+		const row = await api.getReleaseCatalogByScopeKey(require_handlerParameters.decodeMaybe(require_handlerParameters.requireRouteParam(params, "scopeKey")) ?? "");
+		return row === null ? unavailable() : Response.json({ data: row }, { status: 200 });
+	},
+	getReleaseCatalogs: async (_params, request, api) => {
+		if (api.getReleaseCatalogs === void 0) return unavailable();
+		const url = new URL(request.url);
+		const limit = Number(url.searchParams.get("limit") ?? "100");
+		if (!Number.isSafeInteger(limit) || limit <= 0 || limit > 1e3) throw new require_handlerErrors.HandlerBadRequestError("Invalid Release catalog list query");
+		return Response.json({ data: await api.getReleaseCatalogs({
+			afterScopeKey: url.searchParams.get("afterScopeKey") ?? void 0,
+			limit
+		}) });
+	},
+	updateRelease: async (params, request, api) => {
+		if (api.updateReleasePolicy === void 0) return unavailable();
+		const input = await parsePolicyInput(request);
+		return mutationResponse(() => api.updateReleasePolicy({
+			...input,
+			releaseId: require_handlerParameters.requireRouteParam(params, "id")
+		}));
+	},
+	preflightRelease: async (params, request, api) => {
+		if (api.preflightReleasePolicy === void 0) return unavailable();
+		const input = await parsePolicyInput(request);
+		return mutationResponse(() => api.preflightReleasePolicy({
+			...input,
+			releaseId: require_handlerParameters.requireRouteParam(params, "id")
+		}));
+	},
+	deleteRelease: async (params, request, api) => {
+		if (api.deleteRelease === void 0) return unavailable();
+		const releaseId = require_handlerParameters.requireRouteParam(params, "id");
+		const url = new URL(request.url);
+		if (url.searchParams.get("confirm") !== releaseId) throw new require_handlerErrors.HandlerBadRequestError("Release hard deletion requires confirm=<release-id>");
+		return mutationResponse(() => api.deleteRelease({
+			expectedRevision: parseRevision(url.searchParams.get("expectedRevision")),
+			releaseId
+		}));
+	},
+	rebuildReleaseCatalog: async (params, _request, api) => {
+		if (api.rebuildReleaseCatalog === void 0) return unavailable();
+		return mutationResponse(() => api.rebuildReleaseCatalog(require_handlerParameters.decodeMaybe(require_handlerParameters.requireRouteParam(params, "scopeKey")) ?? ""));
+	},
+	commitDatabase: async (_params, request, api) => {
+		if (api.commitDatabase === void 0) return unavailable();
+		const input = await request.json();
+		return Response.json({ data: await api.commitDatabase(input) });
+	}
+});
+//#endregion
+exports.createReleaseManagementRouteHandlers = createReleaseManagementRouteHandlers;