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

package/dist/core/releases.cjs

@@ -0,0 +1,193 @@
+const require_reads = require("./reads.cjs");
+const require_writes = require("./writes.cjs");
+let _hot_updater_plugin_core = require("@hot-updater/plugin-core");
+let _hot_updater_protocol = require("@hot-updater/protocol");
+//#region src/core/releases.ts
+const PAGE = 500;
+const fail = (code, message) => {
+	throw new _hot_updater_plugin_core.ReleaseCatalogMutationError(code, message);
+};
+const checkScope = (scope) => {
+	const channelKey = (0, _hot_updater_protocol.encodeChannelKey)(scope.channelName);
+	const expected = scope.strategy === "APP_VERSION" ? (0, _hot_updater_protocol.createReleaseCatalogScopeKey)({
+		channelKey,
+		platform: scope.platform,
+		strategy: "APP_VERSION"
+	}) : (0, _hot_updater_protocol.createReleaseCatalogScopeKey)({
+		channelKey,
+		fingerprintHash: scope.fingerprintHash ?? "",
+		platform: scope.platform,
+		strategy: "FINGERPRINT"
+	});
+	if (scope.strategy === "FINGERPRINT" !== (scope.fingerprintHash !== null) || scope.scopeKey !== expected) fail("INVALID_SCOPE", "Release catalog scope metadata is inconsistent");
+};
+/** A scope's enabled releases, all of them, under the catalog's guard. */
+const enabledReleases = async (tx, scopeKey) => {
+	const rows = [];
+	let cursor;
+	do {
+		const page = await tx.findMany("releases", {
+			index: "byScopeEnabled",
+			where: {
+				scope_key: scopeKey,
+				enabled: true
+			},
+			limit: PAGE,
+			...cursor === void 0 ? {} : { cursor }
+		});
+		rows.push(...page.rows.map(require_reads.toReleaseRow));
+		cursor = page.next;
+	} while (cursor !== void 0);
+	return rows;
+};
+/** The scope's newest release id: `byScope` descending, limit 1. */
+const latestReleaseId = async (tx, scopeKey) => {
+	const { rows } = await tx.findMany("releases", {
+		index: "byScope",
+		where: { scope_key: scopeKey },
+		order: "desc",
+		limit: 1
+	});
+	return rows[0]?.id ?? null;
+};
+/** Compiles `enabled` and writes it as the scope's next catalog generation. */
+const writeCatalog = async (tx, scope, stored, enabled, updatedAtMs) => {
+	const compilation = await (0, _hot_updater_plugin_core.compileReleaseCatalog)({
+		strategy: scope.strategy,
+		releases: enabled.map(_hot_updater_plugin_core.releaseRowToRelease)
+	});
+	const generation = (stored.generation ?? 0) + 1;
+	if (!Number.isSafeInteger(generation)) fail("CATALOG_GENERATION_EXHAUSTED", `Catalog "${scope.scopeKey}" exhausted its generation counter`);
+	const catalog = {
+		scope_key: scope.scopeKey,
+		catalog_id: stored.catalog?.catalog_id ?? (0, _hot_updater_plugin_core.createUUIDv7)(),
+		strategy: scope.strategy,
+		channel_id: scope.channelId,
+		channel_key: (0, _hot_updater_protocol.encodeChannelKey)(scope.channelName),
+		platform: scope.platform,
+		fingerprint_hash: scope.fingerprintHash,
+		generation,
+		payload: compilation.canonicalPayload,
+		catalog_hash: compilation.catalogHash,
+		byte_size: compilation.byteSize,
+		is_tombstone: compilation.payload.releaseDescriptors.length === 0,
+		updated_at_ms: updatedAtMs
+	};
+	const { scope_key: _scopeKey, ...set } = catalog;
+	if (stored.row === null) tx.create("release_catalogs", catalog);
+	else tx.update("release_catalogs", stored.row, set);
+	return {
+		catalog,
+		compilation
+	};
+};
+/** The scope's catalog row, and its compiled catalog and generation if it has one. */
+const readCatalog = async (tx, scopeKey) => {
+	const row = await tx.findOne("release_catalogs", { scope_key: scopeKey });
+	return {
+		row,
+		generation: row?.generation ?? null,
+		catalog: row === null ? null : require_reads.toCatalogRow(row)
+	};
+};
+/** A scope with releases and no compiled catalog lost its history. */
+const assertHistory = (stored, hasReleases) => {
+	if (stored.catalog === null && hasReleases) fail("CATALOG_IDENTITY_MISSING", "Catalog history is missing. Restore its catalog row from backup before rebuilding or deploying.");
+};
+/** One release change and its scope's next catalog, inside `tx`. */
+const changeRelease = async (tx, { scope, change, bundle, updatedAtMs }) => {
+	checkScope(scope);
+	const stored = await readCatalog(tx, scope.scopeKey);
+	const enabled = await enabledReleases(tx, scope.scopeKey);
+	if (bundle !== void 0) {
+		require_writes.insertBundle(tx, bundle.row);
+		for (const patch of bundle.patches) tx.create("bundle_patches", patch);
+	}
+	let before = null;
+	let release;
+	if (change.operation === "insert") {
+		const latest = await latestReleaseId(tx, scope.scopeKey);
+		assertHistory(stored, latest !== null);
+		const floor = [latest, bundle && (0, _hot_updater_plugin_core.isUUIDv7)(bundle.row.id) ? bundle.row.id : null].filter((id) => id !== null).sort().at(-1);
+		const id = change.row.id ?? (0, _hot_updater_plugin_core.createUUIDv7After)(floor ?? null);
+		if (latest !== null && id <= latest) fail("NON_MONOTONIC_RELEASE_ID", `Release "${id}" must sort after "${latest}"`);
+		release = {
+			...change.row,
+			id
+		};
+		if (release.scope_key !== scope.scopeKey || release.channel_id !== scope.channelId || release.platform !== scope.platform || release.strategy !== scope.strategy || release.fingerprint_hash !== scope.fingerprintHash || release.revision !== 1) fail("INVALID_SCOPE", "Inserted Release does not match its catalog scope");
+		tx.create("releases", release);
+	} else {
+		const row = await tx.findOne("releases", { id: change.id });
+		if (row === null || row.scope_key !== scope.scopeKey) return fail("RELEASE_NOT_FOUND", `Release "${change.id}" was not found in scope "${scope.scopeKey}"`);
+		assertHistory(stored, true);
+		before = require_reads.toReleaseRow(row);
+		if (change.operation === "delete") {
+			await tx.delete("releases", row);
+			release = null;
+		} else {
+			const set = {
+				...change.update,
+				revision: before.revision + 1
+			};
+			tx.update("releases", row, set);
+			release = {
+				...before,
+				...set
+			};
+		}
+	}
+	const changedId = before?.id ?? release?.id;
+	const next = [...enabled.filter(({ id }) => id !== changedId), ...release?.enabled ? [release] : []].sort((left, right) => left.id < right.id ? -1 : 1);
+	const { catalog, compilation } = await writeCatalog(tx, scope, stored, next, updatedAtMs);
+	return {
+		catalog,
+		release,
+		diagnostics: compilation.diagnostics
+	};
+};
+/**
+* Release changes rooted at their catalogs: each reads its scope's catalog
+* and enabled releases, applies the change, and writes the next catalog
+* generation, all in one transaction. A concurrent change in a scope bumps
+* its catalog row, so this transaction reruns instead of publishing a stale
+* catalog.
+*/
+const changeReleases = (db, inputs) => {
+	if (new Set(inputs.map(({ scope }) => scope.scopeKey)).size !== inputs.length) fail("INVALID_SCOPE", "A batch cannot change one catalog scope twice");
+	return db.transaction(async (tx) => {
+		const results = [];
+		for (const input of inputs) results.push(await changeRelease(tx, input));
+		return results;
+	});
+};
+/** Recompiles a scope's catalog from its enabled releases inside `tx`; an unchanged catalog is not rewritten. */
+const rebuildScope = async (tx, scope, updatedAtMs) => {
+	checkScope(scope);
+	const stored = await readCatalog(tx, scope.scopeKey);
+	assertHistory(stored, await latestReleaseId(tx, scope.scopeKey) !== null);
+	const enabled = await enabledReleases(tx, scope.scopeKey);
+	const compilation = await (0, _hot_updater_plugin_core.compileReleaseCatalog)({
+		strategy: scope.strategy,
+		releases: enabled.map(_hot_updater_plugin_core.releaseRowToRelease)
+	});
+	const current = stored.catalog;
+	if (current !== null && current.strategy === scope.strategy && current.channel_id === scope.channelId && current.channel_key === (0, _hot_updater_protocol.encodeChannelKey)(scope.channelName) && current.platform === scope.platform && current.fingerprint_hash === scope.fingerprintHash && current.catalog_hash === compilation.catalogHash) return {
+		catalog: current,
+		current,
+		changed: false,
+		diagnostics: compilation.diagnostics
+	};
+	const written = await writeCatalog(tx, scope, stored, enabled, updatedAtMs);
+	return {
+		catalog: written.catalog,
+		current,
+		changed: true,
+		diagnostics: written.compilation.diagnostics
+	};
+};
+//#endregion
+exports.changeRelease = changeRelease;
+exports.changeReleases = changeReleases;
+exports.readCatalog = readCatalog;
+exports.rebuildScope = rebuildScope;

package/dist/core/releases.mjs

@@ -0,0 +1,190 @@
+import { toCatalogRow, toReleaseRow } from "./reads.mjs";
+import { insertBundle } from "./writes.mjs";
+import { ReleaseCatalogMutationError, compileReleaseCatalog, createUUIDv7, createUUIDv7After, isUUIDv7, releaseRowToRelease } from "@hot-updater/plugin-core";
+import { createReleaseCatalogScopeKey, encodeChannelKey } from "@hot-updater/protocol";
+//#region src/core/releases.ts
+const PAGE = 500;
+const fail = (code, message) => {
+	throw new ReleaseCatalogMutationError(code, message);
+};
+const checkScope = (scope) => {
+	const channelKey = encodeChannelKey(scope.channelName);
+	const expected = scope.strategy === "APP_VERSION" ? createReleaseCatalogScopeKey({
+		channelKey,
+		platform: scope.platform,
+		strategy: "APP_VERSION"
+	}) : createReleaseCatalogScopeKey({
+		channelKey,
+		fingerprintHash: scope.fingerprintHash ?? "",
+		platform: scope.platform,
+		strategy: "FINGERPRINT"
+	});
+	if (scope.strategy === "FINGERPRINT" !== (scope.fingerprintHash !== null) || scope.scopeKey !== expected) fail("INVALID_SCOPE", "Release catalog scope metadata is inconsistent");
+};
+/** A scope's enabled releases, all of them, under the catalog's guard. */
+const enabledReleases = async (tx, scopeKey) => {
+	const rows = [];
+	let cursor;
+	do {
+		const page = await tx.findMany("releases", {
+			index: "byScopeEnabled",
+			where: {
+				scope_key: scopeKey,
+				enabled: true
+			},
+			limit: PAGE,
+			...cursor === void 0 ? {} : { cursor }
+		});
+		rows.push(...page.rows.map(toReleaseRow));
+		cursor = page.next;
+	} while (cursor !== void 0);
+	return rows;
+};
+/** The scope's newest release id: `byScope` descending, limit 1. */
+const latestReleaseId = async (tx, scopeKey) => {
+	const { rows } = await tx.findMany("releases", {
+		index: "byScope",
+		where: { scope_key: scopeKey },
+		order: "desc",
+		limit: 1
+	});
+	return rows[0]?.id ?? null;
+};
+/** Compiles `enabled` and writes it as the scope's next catalog generation. */
+const writeCatalog = async (tx, scope, stored, enabled, updatedAtMs) => {
+	const compilation = await compileReleaseCatalog({
+		strategy: scope.strategy,
+		releases: enabled.map(releaseRowToRelease)
+	});
+	const generation = (stored.generation ?? 0) + 1;
+	if (!Number.isSafeInteger(generation)) fail("CATALOG_GENERATION_EXHAUSTED", `Catalog "${scope.scopeKey}" exhausted its generation counter`);
+	const catalog = {
+		scope_key: scope.scopeKey,
+		catalog_id: stored.catalog?.catalog_id ?? createUUIDv7(),
+		strategy: scope.strategy,
+		channel_id: scope.channelId,
+		channel_key: encodeChannelKey(scope.channelName),
+		platform: scope.platform,
+		fingerprint_hash: scope.fingerprintHash,
+		generation,
+		payload: compilation.canonicalPayload,
+		catalog_hash: compilation.catalogHash,
+		byte_size: compilation.byteSize,
+		is_tombstone: compilation.payload.releaseDescriptors.length === 0,
+		updated_at_ms: updatedAtMs
+	};
+	const { scope_key: _scopeKey, ...set } = catalog;
+	if (stored.row === null) tx.create("release_catalogs", catalog);
+	else tx.update("release_catalogs", stored.row, set);
+	return {
+		catalog,
+		compilation
+	};
+};
+/** The scope's catalog row, and its compiled catalog and generation if it has one. */
+const readCatalog = async (tx, scopeKey) => {
+	const row = await tx.findOne("release_catalogs", { scope_key: scopeKey });
+	return {
+		row,
+		generation: row?.generation ?? null,
+		catalog: row === null ? null : toCatalogRow(row)
+	};
+};
+/** A scope with releases and no compiled catalog lost its history. */
+const assertHistory = (stored, hasReleases) => {
+	if (stored.catalog === null && hasReleases) fail("CATALOG_IDENTITY_MISSING", "Catalog history is missing. Restore its catalog row from backup before rebuilding or deploying.");
+};
+/** One release change and its scope's next catalog, inside `tx`. */
+const changeRelease = async (tx, { scope, change, bundle, updatedAtMs }) => {
+	checkScope(scope);
+	const stored = await readCatalog(tx, scope.scopeKey);
+	const enabled = await enabledReleases(tx, scope.scopeKey);
+	if (bundle !== void 0) {
+		insertBundle(tx, bundle.row);
+		for (const patch of bundle.patches) tx.create("bundle_patches", patch);
+	}
+	let before = null;
+	let release;
+	if (change.operation === "insert") {
+		const latest = await latestReleaseId(tx, scope.scopeKey);
+		assertHistory(stored, latest !== null);
+		const floor = [latest, bundle && isUUIDv7(bundle.row.id) ? bundle.row.id : null].filter((id) => id !== null).sort().at(-1);
+		const id = change.row.id ?? createUUIDv7After(floor ?? null);
+		if (latest !== null && id <= latest) fail("NON_MONOTONIC_RELEASE_ID", `Release "${id}" must sort after "${latest}"`);
+		release = {
+			...change.row,
+			id
+		};
+		if (release.scope_key !== scope.scopeKey || release.channel_id !== scope.channelId || release.platform !== scope.platform || release.strategy !== scope.strategy || release.fingerprint_hash !== scope.fingerprintHash || release.revision !== 1) fail("INVALID_SCOPE", "Inserted Release does not match its catalog scope");
+		tx.create("releases", release);
+	} else {
+		const row = await tx.findOne("releases", { id: change.id });
+		if (row === null || row.scope_key !== scope.scopeKey) return fail("RELEASE_NOT_FOUND", `Release "${change.id}" was not found in scope "${scope.scopeKey}"`);
+		assertHistory(stored, true);
+		before = toReleaseRow(row);
+		if (change.operation === "delete") {
+			await tx.delete("releases", row);
+			release = null;
+		} else {
+			const set = {
+				...change.update,
+				revision: before.revision + 1
+			};
+			tx.update("releases", row, set);
+			release = {
+				...before,
+				...set
+			};
+		}
+	}
+	const changedId = before?.id ?? release?.id;
+	const next = [...enabled.filter(({ id }) => id !== changedId), ...release?.enabled ? [release] : []].sort((left, right) => left.id < right.id ? -1 : 1);
+	const { catalog, compilation } = await writeCatalog(tx, scope, stored, next, updatedAtMs);
+	return {
+		catalog,
+		release,
+		diagnostics: compilation.diagnostics
+	};
+};
+/**
+* Release changes rooted at their catalogs: each reads its scope's catalog
+* and enabled releases, applies the change, and writes the next catalog
+* generation, all in one transaction. A concurrent change in a scope bumps
+* its catalog row, so this transaction reruns instead of publishing a stale
+* catalog.
+*/
+const changeReleases = (db, inputs) => {
+	if (new Set(inputs.map(({ scope }) => scope.scopeKey)).size !== inputs.length) fail("INVALID_SCOPE", "A batch cannot change one catalog scope twice");
+	return db.transaction(async (tx) => {
+		const results = [];
+		for (const input of inputs) results.push(await changeRelease(tx, input));
+		return results;
+	});
+};
+/** Recompiles a scope's catalog from its enabled releases inside `tx`; an unchanged catalog is not rewritten. */
+const rebuildScope = async (tx, scope, updatedAtMs) => {
+	checkScope(scope);
+	const stored = await readCatalog(tx, scope.scopeKey);
+	assertHistory(stored, await latestReleaseId(tx, scope.scopeKey) !== null);
+	const enabled = await enabledReleases(tx, scope.scopeKey);
+	const compilation = await compileReleaseCatalog({
+		strategy: scope.strategy,
+		releases: enabled.map(releaseRowToRelease)
+	});
+	const current = stored.catalog;
+	if (current !== null && current.strategy === scope.strategy && current.channel_id === scope.channelId && current.channel_key === encodeChannelKey(scope.channelName) && current.platform === scope.platform && current.fingerprint_hash === scope.fingerprintHash && current.catalog_hash === compilation.catalogHash) return {
+		catalog: current,
+		current,
+		changed: false,
+		diagnostics: compilation.diagnostics
+	};
+	const written = await writeCatalog(tx, scope, stored, enabled, updatedAtMs);
+	return {
+		catalog: written.catalog,
+		current,
+		changed: true,
+		diagnostics: written.compilation.diagnostics
+	};
+};
+//#endregion
+export { changeRelease, changeReleases, readCatalog, rebuildScope };

package/dist/core/writes.cjs

@@ -0,0 +1,96 @@
+const require_reads = require("./reads.cjs");
+let _hot_updater_plugin_core = require("@hot-updater/plugin-core");
+//#region src/core/writes.ts
+const PAGE = 500;
+/** Moves one bundle into or out of its platform's total and the overall total. */
+const countBundle = (tx, platform, delta) => {
+	for (const key of [platform, "*"]) tx.aggregate("bundle_totals", { platform_key: key }, { bundles: delta });
+};
+const insertBundle = (tx, row) => {
+	tx.create("bundles", row);
+	countBundle(tx, row.platform, 1);
+};
+const updateBundle = (tx, current, set) => {
+	tx.update("bundles", current, set);
+	if (set.platform !== void 0 && set.platform !== current.platform) {
+		countBundle(tx, current.platform, -1);
+		countBundle(tx, set.platform, 1);
+	}
+};
+/** Deletes a bundle and, by cascade, every patch to or from it; a release on it refuses. */
+const deleteBundle = async (tx, current) => {
+	await tx.delete("bundles", current);
+	countBundle(tx, current.platform, -1);
+};
+/**
+* Replaces a bundle's patches with `rows`: kept patches are updated where
+* they changed, others deleted or created, so no key is written twice.
+*/
+const replaceBundlePatches = async (tx, bundle, rows) => {
+	const wanted = new Map(rows.map((row) => [row.id, row]));
+	const count = bundle._refs_bundle_patches_bundle_id ?? 0;
+	let cursor;
+	for (let seen = 0; seen < count;) {
+		const page = await tx.findMany("bundle_patches", {
+			index: "byBundle",
+			where: { bundle_id: bundle.id },
+			limit: Math.min(count - seen, PAGE),
+			...cursor === void 0 ? {} : { cursor }
+		});
+		for (const stored of page.rows) {
+			const next = wanted.get(stored.id);
+			wanted.delete(stored.id);
+			if (next === void 0) {
+				await tx.delete("bundle_patches", stored);
+				continue;
+			}
+			const set = Object.fromEntries(Object.entries(next).filter(([field, value]) => field !== "id" && stored[field] !== value));
+			if (Object.keys(set).length > 0) tx.update("bundle_patches", stored, set);
+		}
+		seen += page.rows.length;
+		if (page.next === void 0) break;
+		cursor = page.next;
+	}
+	for (const row of wanted.values()) tx.create("bundle_patches", row);
+};
+/** A channel by name, created when missing; a concurrent creator's row is returned instead. */
+const insertChannel = async (db, row) => {
+	for (let attempt = 1;; attempt += 1) try {
+		return await db.transaction(async (tx) => {
+			const existing = await tx.findOne("channels", { name: row.name });
+			if (existing !== null) return {
+				row: require_reads.toChannelRow(existing),
+				inserted: false
+			};
+			tx.create("channels", row);
+			return {
+				row,
+				inserted: true
+			};
+		});
+	} catch (error) {
+		if (attempt < 3 && error instanceof _hot_updater_plugin_core.DatabaseConstraintError && (error.reason === "unique" || error.reason === "exists")) continue;
+		throw error;
+	}
+};
+/** Deletes a channel no release uses: 1 read + 1 write. */
+const deleteChannel = (db, id) => db.transaction(async (tx) => {
+	const row = await tx.findOne("channels", { id });
+	if (row === null) return {
+		deleted: false,
+		reason: "not_found"
+	};
+	if ((row._refs_releases_channel_id ?? 0) > 0) return {
+		deleted: false,
+		reason: "not_empty"
+	};
+	await tx.delete("channels", row);
+	return { deleted: true };
+});
+//#endregion
+exports.deleteBundle = deleteBundle;
+exports.deleteChannel = deleteChannel;
+exports.insertBundle = insertBundle;
+exports.insertChannel = insertChannel;
+exports.replaceBundlePatches = replaceBundlePatches;
+exports.updateBundle = updateBundle;

package/dist/core/writes.mjs

@@ -0,0 +1,91 @@
+import { toChannelRow } from "./reads.mjs";
+import { DatabaseConstraintError } from "@hot-updater/plugin-core";
+//#region src/core/writes.ts
+const PAGE = 500;
+/** Moves one bundle into or out of its platform's total and the overall total. */
+const countBundle = (tx, platform, delta) => {
+	for (const key of [platform, "*"]) tx.aggregate("bundle_totals", { platform_key: key }, { bundles: delta });
+};
+const insertBundle = (tx, row) => {
+	tx.create("bundles", row);
+	countBundle(tx, row.platform, 1);
+};
+const updateBundle = (tx, current, set) => {
+	tx.update("bundles", current, set);
+	if (set.platform !== void 0 && set.platform !== current.platform) {
+		countBundle(tx, current.platform, -1);
+		countBundle(tx, set.platform, 1);
+	}
+};
+/** Deletes a bundle and, by cascade, every patch to or from it; a release on it refuses. */
+const deleteBundle = async (tx, current) => {
+	await tx.delete("bundles", current);
+	countBundle(tx, current.platform, -1);
+};
+/**
+* Replaces a bundle's patches with `rows`: kept patches are updated where
+* they changed, others deleted or created, so no key is written twice.
+*/
+const replaceBundlePatches = async (tx, bundle, rows) => {
+	const wanted = new Map(rows.map((row) => [row.id, row]));
+	const count = bundle._refs_bundle_patches_bundle_id ?? 0;
+	let cursor;
+	for (let seen = 0; seen < count;) {
+		const page = await tx.findMany("bundle_patches", {
+			index: "byBundle",
+			where: { bundle_id: bundle.id },
+			limit: Math.min(count - seen, PAGE),
+			...cursor === void 0 ? {} : { cursor }
+		});
+		for (const stored of page.rows) {
+			const next = wanted.get(stored.id);
+			wanted.delete(stored.id);
+			if (next === void 0) {
+				await tx.delete("bundle_patches", stored);
+				continue;
+			}
+			const set = Object.fromEntries(Object.entries(next).filter(([field, value]) => field !== "id" && stored[field] !== value));
+			if (Object.keys(set).length > 0) tx.update("bundle_patches", stored, set);
+		}
+		seen += page.rows.length;
+		if (page.next === void 0) break;
+		cursor = page.next;
+	}
+	for (const row of wanted.values()) tx.create("bundle_patches", row);
+};
+/** A channel by name, created when missing; a concurrent creator's row is returned instead. */
+const insertChannel = async (db, row) => {
+	for (let attempt = 1;; attempt += 1) try {
+		return await db.transaction(async (tx) => {
+			const existing = await tx.findOne("channels", { name: row.name });
+			if (existing !== null) return {
+				row: toChannelRow(existing),
+				inserted: false
+			};
+			tx.create("channels", row);
+			return {
+				row,
+				inserted: true
+			};
+		});
+	} catch (error) {
+		if (attempt < 3 && error instanceof DatabaseConstraintError && (error.reason === "unique" || error.reason === "exists")) continue;
+		throw error;
+	}
+};
+/** Deletes a channel no release uses: 1 read + 1 write. */
+const deleteChannel = (db, id) => db.transaction(async (tx) => {
+	const row = await tx.findOne("channels", { id });
+	if (row === null) return {
+		deleted: false,
+		reason: "not_found"
+	};
+	if ((row._refs_releases_channel_id ?? 0) > 0) return {
+		deleted: false,
+		reason: "not_empty"
+	};
+	await tx.delete("channels", row);
+	return { deleted: true };
+});
+//#endregion
+export { deleteBundle, deleteChannel, insertBundle, insertChannel, replaceBundlePatches, updateBundle };