@hot-updater/server 1.0.0-rc.1 → 1.0.0-rc.16

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/core";
+//#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/schema.cjs

@@ -0,0 +1,279 @@
+const require_schema = require("../database/schema.cjs");
+//#region src/core/schema.ts
+/** A channel's id is `channel:` and its name's channel key, so ids share channel_key's bound. */
+const CHANNEL_ID = {
+	type: "string",
+	maxLength: 1408,
+	ascii: true
+};
+/** Core's schema version: the `schema.core` settings row. */
+const HOT_UPDATER_SCHEMA_VERSION = "1.0.0";
+const coreSchema = {
+	bundles: require_schema.defineTable({
+		id: {
+			type: "string",
+			maxLength: 36
+		},
+		platform: {
+			type: "string",
+			maxLength: 16
+		},
+		git_commit_hash: {
+			type: "string",
+			maxLength: 255,
+			required: false
+		},
+		metadata: { type: "json" },
+		manifest_storage_uri: { type: "string" },
+		manifest_file_hash: { type: "string" },
+		asset_base_storage_uri: { type: "string" }
+	}, {
+		key: ["id"],
+		indexes: {
+			byPlatform: {
+				eq: ["platform"],
+				sort: ["id"]
+			},
+			all: {
+				eq: [],
+				sort: ["id"]
+			}
+		}
+	}),
+	bundle_patches: require_schema.defineTable({
+		id: {
+			type: "string",
+			maxLength: 255
+		},
+		bundle_id: {
+			type: "string",
+			maxLength: 36,
+			references: {
+				model: "bundles",
+				onDelete: "cascade"
+			}
+		},
+		base_bundle_id: {
+			type: "string",
+			maxLength: 36,
+			references: {
+				model: "bundles",
+				onDelete: "cascade"
+			}
+		},
+		base_file_hash: { type: "string" },
+		patch_file_hash: { type: "string" },
+		patch_storage_uri: { type: "string" },
+		byte_size: { type: "integer" },
+		order_index: { type: "integer" }
+	}, {
+		key: ["id"],
+		indexes: {
+			pair: {
+				eq: ["bundle_id", "base_bundle_id"],
+				sort: [],
+				unique: true
+			},
+			byBundle: {
+				eq: ["bundle_id"],
+				sort: ["order_index"],
+				root: { model: "bundles" }
+			},
+			byBase: {
+				eq: ["base_bundle_id"],
+				sort: ["bundle_id"]
+			}
+		}
+	}),
+	releases: require_schema.defineTable({
+		id: {
+			type: "string",
+			maxLength: 36
+		},
+		revision: { type: "integer" },
+		scope_key: {
+			type: "string",
+			maxLength: 2048,
+			ascii: true
+		},
+		channel_id: {
+			...CHANNEL_ID,
+			references: {
+				model: "channels",
+				onDelete: "restrict"
+			}
+		},
+		platform: {
+			type: "string",
+			maxLength: 16
+		},
+		kind: {
+			type: "string",
+			maxLength: 16
+		},
+		bundle_id: {
+			type: "string",
+			maxLength: 36,
+			required: false,
+			references: {
+				model: "bundles",
+				onDelete: "restrict"
+			}
+		},
+		strategy: {
+			type: "string",
+			maxLength: 16
+		},
+		target_app_version: {
+			type: "string",
+			required: false
+		},
+		fingerprint_hash: {
+			type: "string",
+			maxLength: 255,
+			required: false
+		},
+		enabled: { type: "boolean" },
+		should_force_update: { type: "boolean" },
+		message: {
+			type: "string",
+			required: false
+		},
+		rollout_cohort_count: { type: "integer" },
+		target_cohorts: { type: "json" },
+		operation: {
+			type: "string",
+			maxLength: 16
+		},
+		source_release_id: {
+			type: "string",
+			maxLength: 36,
+			required: false,
+			references: {
+				model: "releases",
+				onDelete: "none"
+			}
+		},
+		created_at_ms: { type: "integer" },
+		updated_at_ms: { type: "integer" }
+	}, {
+		key: ["id"],
+		indexes: {
+			byScope: {
+				eq: ["scope_key"],
+				sort: ["id"],
+				root: { model: "release_catalogs" }
+			},
+			byScopeEnabled: {
+				eq: ["scope_key", "enabled"],
+				sort: ["id"],
+				root: { model: "release_catalogs" }
+			},
+			byChannelPlatform: {
+				eq: ["channel_id", "platform"],
+				sort: ["id"]
+			},
+			byChannelPlatformEnabled: {
+				eq: [
+					"channel_id",
+					"platform",
+					"enabled"
+				],
+				sort: ["id"]
+			},
+			byBundle: {
+				eq: ["bundle_id"],
+				sort: ["id"]
+			},
+			all: {
+				eq: [],
+				sort: ["id"]
+			}
+		}
+	}),
+	release_catalogs: require_schema.defineTable({
+		scope_key: {
+			type: "string",
+			maxLength: 2048,
+			ascii: true
+		},
+		catalog_id: {
+			type: "string",
+			maxLength: 255
+		},
+		strategy: {
+			type: "string",
+			maxLength: 16
+		},
+		channel_id: {
+			...CHANNEL_ID,
+			references: {
+				model: "channels",
+				onDelete: "none"
+			}
+		},
+		channel_key: {
+			type: "string",
+			maxLength: 1400,
+			ascii: true
+		},
+		platform: {
+			type: "string",
+			maxLength: 16
+		},
+		fingerprint_hash: {
+			type: "string",
+			maxLength: 255,
+			required: false
+		},
+		generation: { type: "integer" },
+		payload: { type: "string" },
+		catalog_hash: {
+			type: "string",
+			maxLength: 71
+		},
+		byte_size: { type: "integer" },
+		is_tombstone: { type: "boolean" },
+		updated_at_ms: { type: "integer" }
+	}, {
+		key: ["scope_key"],
+		indexes: { all: {
+			eq: [],
+			sort: ["scope_key"]
+		} }
+	}),
+	channels: require_schema.defineTable({
+		id: CHANNEL_ID,
+		name: {
+			type: "string",
+			maxLength: 255,
+			unique: true
+		}
+	}, {
+		key: ["id"],
+		indexes: { all: {
+			eq: [],
+			sort: ["name"]
+		} }
+	}),
+	bundle_totals: require_schema.defineAggregate({ platform_key: {
+		type: "string",
+		maxLength: 16
+	} }, {
+		key: ["platform_key"],
+		counters: ["bundles"],
+		indexes: { byPlatform: {
+			eq: ["platform_key"],
+			sort: []
+		} }
+	})
+};
+/** Core's module: always installed, never a plugin. */
+const coreModule = {
+	id: "core",
+	schema: coreSchema
+};
+//#endregion
+exports.HOT_UPDATER_SCHEMA_VERSION = HOT_UPDATER_SCHEMA_VERSION;
+exports.coreModule = coreModule;
+exports.coreSchema = coreSchema;